update excel tests

Author: jorisvandenbossche

pandas/tests/io/excel/test_readers.py

@@ -134,18 +134,8 @@ def df_ref(datapath):
     return df_ref
 
 
-def get_exp_unit(read_ext: str, engine: str | None) -> str:
-    unit = "us"
-    if (read_ext == ".ods") ^ (engine == "calamine"):
-        unit = "s"
-    return unit
-
-
 def adjust_expected(expected: DataFrame, read_ext: str, engine: str | None) -> None:
     expected.index.name = None
-    unit = get_exp_unit(read_ext, engine)
-    # error: "Index" has no attribute "as_unit"
-    expected.index = expected.index.as_unit(unit)  # type: ignore[attr-defined]
 
 
 def xfail_datetimes_with_pyxlsb(engine, request):
@@ -490,7 +480,6 @@ def test_excel_table(self, request, engine, read_ext, df_ref):
     def test_reader_special_dtypes(self, request, engine, read_ext):
         xfail_datetimes_with_pyxlsb(engine, request)
 
-        unit = get_exp_unit(read_ext, engine)
         expected = DataFrame.from_dict(
             {
                 "IntCol": [1, 2, -3, 4, 0],
@@ -506,7 +495,6 @@ def test_reader_special_dtypes(self, request, engine, read_ext):
                         datetime(2013, 12, 14),
                         datetime(2015, 3, 14),
                     ],
-                    dtype=f"M8[{unit}]",
                 ),
             },
         )
@@ -665,8 +653,6 @@ def test_dtype_backend(self, read_ext, dtype_backend, engine, tmp_excel):
             expected["j"] = ArrowExtensionArray(pa.array([None, None]))
         else:
             expected = df
-            unit = get_exp_unit(read_ext, engine)
-            expected["i"] = expected["i"].astype(f"M8[{unit}]")
 
         tm.assert_frame_equal(result, expected)
 
@@ -1034,8 +1020,6 @@ def test_read_excel_multiindex(self, request, engine, read_ext):
         # see gh-4679
         xfail_datetimes_with_pyxlsb(engine, request)
 
-        unit = get_exp_unit(read_ext, engine)
-
         mi = MultiIndex.from_product([["foo", "bar"], ["a", "b"]])
         mi_file = "testmultiindex" + read_ext
 
@@ -1049,8 +1033,6 @@ def test_read_excel_multiindex(self, request, engine, read_ext):
             ],
             columns=mi,
         )
-        expected[mi[2]] = expected[mi[2]].astype(f"M8[{unit}]")
-
         actual = pd.read_excel(
             mi_file, sheet_name="mi_column", header=[0, 1], index_col=0
         )
@@ -1130,7 +1112,6 @@ def test_read_excel_multiindex_blank_after_name(
         mi_file = "testmultiindex" + read_ext
         mi = MultiIndex.from_product([["foo", "bar"], ["a", "b"]], names=["c1", "c2"])
 
-        unit = get_exp_unit(read_ext, engine)
         expected = DataFrame(
             [
                 [1, 2.5, pd.Timestamp("2015-01-01"), True],
@@ -1144,7 +1125,6 @@ def test_read_excel_multiindex_blank_after_name(
                 names=["ilvl1", "ilvl2"],
             ),
         )
-        expected[mi[2]] = expected[mi[2]].astype(f"M8[{unit}]")
         result = pd.read_excel(
             mi_file,
             sheet_name=sheet_name,
@@ -1248,8 +1228,6 @@ def test_read_excel_skiprows(self, request, engine, read_ext):
         # GH 4903
         xfail_datetimes_with_pyxlsb(engine, request)
 
-        unit = get_exp_unit(read_ext, engine)
-
         actual = pd.read_excel(
             "testskiprows" + read_ext, sheet_name="skiprows_list", skiprows=[0, 2]
         )
@@ -1262,7 +1240,6 @@ def test_read_excel_skiprows(self, request, engine, read_ext):
             ],
             columns=["a", "b", "c", "d"],
         )
-        expected["c"] = expected["c"].astype(f"M8[{unit}]")
         tm.assert_frame_equal(actual, expected)
 
         actual = pd.read_excel(
@@ -1295,13 +1272,11 @@ def test_read_excel_skiprows(self, request, engine, read_ext):
             ],
             columns=["a", "b", "c", "d"],
         )
-        expected["c"] = expected["c"].astype(f"M8[{unit}]")
         tm.assert_frame_equal(actual, expected)
 
     def test_read_excel_skiprows_callable_not_in(self, request, engine, read_ext):
         # GH 4903
         xfail_datetimes_with_pyxlsb(engine, request)
-        unit = get_exp_unit(read_ext, engine)
 
         actual = pd.read_excel(
             "testskiprows" + read_ext,
@@ -1317,7 +1292,6 @@ def test_read_excel_skiprows_callable_not_in(self, request, engine, read_ext):
             ],
             columns=["a", "b", "c", "d"],
         )
-        expected["c"] = expected["c"].astype(f"M8[{unit}]")
         tm.assert_frame_equal(actual, expected)
 
     def test_read_excel_nrows(self, read_ext):
@@ -1687,9 +1661,7 @@ def test_read_datetime_multiindex(self, request, engine, read_ext):
         with pd.ExcelFile(f) as excel:
             actual = pd.read_excel(excel, header=[0, 1], index_col=0, engine=engine)
 
-        unit = get_exp_unit(read_ext, engine)
-
-        dti = pd.DatetimeIndex(["2020-02-29", "2020-03-01"], dtype=f"M8[{unit}]")
+        dti = pd.DatetimeIndex(["2020-02-29", "2020-03-01"])
         expected_column_index = MultiIndex.from_arrays(
             [dti[:1], dti[1:]],
             names=[

pandas/tests/io/excel/test_writers.py

@@ -37,12 +37,6 @@
 from pandas.io.excel._util import _writers
 
 
-def get_exp_unit(path: str) -> str:
-    if path.endswith(".ods"):
-        return "s"
-    return "us"
-
-
 @pytest.fixture
 def frame(float_frame):
     """
@@ -297,13 +291,12 @@ def test_read_excel_parse_dates(self, tmp_excel):
 
         res = pd.read_excel(tmp_excel, parse_dates=["date_strings"], index_col=0)
         expected = df[:]
-        expected["date_strings"] = expected["date_strings"].astype("M8[s]")
+        expected["date_strings"] = expected["date_strings"].astype("M8[us]")
         tm.assert_frame_equal(res, expected)
 
         res = pd.read_excel(
             tmp_excel, parse_dates=["date_strings"], date_format="%m/%d/%Y", index_col=0
         )
-        expected["date_strings"] = expected["date_strings"].astype("M8[s]")
         tm.assert_frame_equal(expected, res)
 
     def test_multiindex_interval_datetimes(self, tmp_excel):
@@ -364,13 +357,6 @@ def test_excel_round_trip_with_periodindex(self, tmp_excel, merge_cells):
                 names=["date", "category"],
             ),
         )
-        time_format = (
-            "datetime64[s]" if tmp_excel.endswith(".ods") else "datetime64[us]"
-        )
-        expected.index = expected.index.set_levels(
-            expected.index.levels[0].astype(time_format), level=0
-        )
-
         tm.assert_frame_equal(result, expected)
 
 
@@ -507,24 +493,20 @@ def test_mixed(self, frame, tmp_excel):
         tm.assert_frame_equal(mixed_frame, recons)
 
     def test_ts_frame(self, tmp_excel):
-        unit = get_exp_unit(tmp_excel)
         df = DataFrame(
             np.random.default_rng(2).standard_normal((5, 4)),
             columns=Index(list("ABCD")),
-            index=date_range("2000-01-01", periods=5, freq="B"),
+            index=date_range("2000-01-01", periods=5, freq="B", unit="us"),
         )
 
         # freq doesn't round-trip
         index = pd.DatetimeIndex(np.asarray(df.index), freq=None)
         df.index = index
 
-        expected = df[:]
-        expected.index = expected.index.as_unit(unit)
-
         df.to_excel(tmp_excel, sheet_name="test1")
         with ExcelFile(tmp_excel) as reader:
             recons = pd.read_excel(reader, sheet_name="test1", index_col=0)
-        tm.assert_frame_equal(expected, recons)
+        tm.assert_frame_equal(recons, df)
 
     def test_basics_with_nan(self, frame, tmp_excel):
         frame = frame.copy()
@@ -594,19 +576,15 @@ def test_inf_roundtrip(self, tmp_excel):
 
     def test_sheets(self, frame, tmp_excel):
         # freq doesn't round-trip
-        unit = get_exp_unit(tmp_excel)
         tsframe = DataFrame(
             np.random.default_rng(2).standard_normal((5, 4)),
             columns=Index(list("ABCD")),
-            index=date_range("2000-01-01", periods=5, freq="B"),
+            index=date_range("2000-01-01", periods=5, freq="B", unit="us"),
         )
 
         index = pd.DatetimeIndex(np.asarray(tsframe.index), freq=None)
         tsframe.index = index
 
-        expected = tsframe[:]
-        expected.index = expected.index.as_unit(unit)
-
         frame = frame.copy()
         frame.iloc[:5, frame.columns.get_loc("A")] = np.nan
 
@@ -623,7 +601,7 @@ def test_sheets(self, frame, tmp_excel):
             recons = pd.read_excel(reader, sheet_name="test1", index_col=0)
             tm.assert_frame_equal(frame, recons)
             recons = pd.read_excel(reader, sheet_name="test2", index_col=0)
-        tm.assert_frame_equal(expected, recons)
+        tm.assert_frame_equal(tsframe, recons)
         assert 2 == len(reader.sheet_names)
         assert "test1" == reader.sheet_names[0]
         assert "test2" == reader.sheet_names[1]
@@ -727,13 +705,12 @@ def test_excel_roundtrip_indexname(self, merge_cells, tmp_excel):
 
     def test_excel_roundtrip_datetime(self, merge_cells, tmp_excel):
         # datetime.date, not sure what to test here exactly
-        unit = get_exp_unit(tmp_excel)
 
         # freq does not round-trip
         tsframe = DataFrame(
             np.random.default_rng(2).standard_normal((5, 4)),
             columns=Index(list("ABCD")),
-            index=date_range("2000-01-01", periods=5, freq="B"),
+            index=date_range("2000-01-01", periods=5, freq="B", unit="us"),
         )
         index = pd.DatetimeIndex(np.asarray(tsframe.index), freq=None)
         tsframe.index = index
@@ -746,15 +723,12 @@ def test_excel_roundtrip_datetime(self, merge_cells, tmp_excel):
         with ExcelFile(tmp_excel) as reader:
             recons = pd.read_excel(reader, sheet_name="test1", index_col=0)
 
-        expected = tsframe[:]
-        expected.index = expected.index.as_unit(unit)
-        tm.assert_frame_equal(expected, recons)
+        tm.assert_frame_equal(tsframe, recons)
 
     def test_excel_date_datetime_format(self, ext, tmp_excel, tmp_path):
         # see gh-4133
         #
         # Excel output format strings
-        unit = get_exp_unit(tmp_excel)
         df = DataFrame(
             [
                 [date(2014, 1, 31), date(1999, 9, 24)],
@@ -771,7 +745,6 @@ def test_excel_date_datetime_format(self, ext, tmp_excel, tmp_path):
             index=["DATE", "DATETIME"],
             columns=["X", "Y"],
         )
-        df_expected = df_expected.astype(f"M8[{unit}]")
 
         filename2 = tmp_path / f"tmp2{ext}"
         filename2.touch()
@@ -791,9 +764,6 @@ def test_excel_date_datetime_format(self, ext, tmp_excel, tmp_path):
         with ExcelFile(filename2) as reader2:
             rs2 = pd.read_excel(reader2, sheet_name="test1", index_col=0)
 
-        # TODO: why do we get different units?
-        rs2 = rs2.astype(f"M8[{unit}]")
-
         tm.assert_frame_equal(rs1, rs2)
 
         # Since the reader returns a datetime object for dates,
@@ -955,15 +925,14 @@ def test_to_excel_multiindex_cols(self, merge_cells, tmp_excel):
 
     def test_to_excel_multiindex_dates(self, merge_cells, tmp_excel):
         # try multiindex with dates
-        unit = get_exp_unit(tmp_excel)
         tsframe = DataFrame(
             np.random.default_rng(2).standard_normal((5, 4)),
             columns=Index(list("ABCD")),
             index=date_range("2000-01-01", periods=5, freq="B"),
         )
         tsframe.index = MultiIndex.from_arrays(
             [
-                tsframe.index.as_unit(unit),
+                tsframe.index.as_unit("us"),
                 np.arange(len(tsframe.index), dtype=np.int64),
             ],
             names=["time", "foo"],
@@ -1314,7 +1283,6 @@ def test_comment_empty_line(self, tmp_excel):
 
     def test_datetimes(self, tmp_excel):
         # Test writing and reading datetimes. For issue #9139. (xref #9185)
-        unit = get_exp_unit(tmp_excel)
         datetimes = [
             datetime(2013, 1, 13, 1, 2, 3),
             datetime(2013, 1, 13, 2, 45, 56),
@@ -1333,8 +1301,7 @@ def test_datetimes(self, tmp_excel):
         write_frame.to_excel(tmp_excel, sheet_name="Sheet1")
         read_frame = pd.read_excel(tmp_excel, sheet_name="Sheet1", header=0)
 
-        expected = write_frame.astype(f"M8[{unit}]")
-        tm.assert_series_equal(expected["A"], read_frame["A"])
+        tm.assert_series_equal(write_frame["A"], read_frame["A"])
 
     def test_bytes_io(self, engine):
         # see gh-7074