update expecteds

Author: jbrockmendel

pandas/core/indexes/datetimes.py

@@ -26,7 +26,10 @@
     to_offset,
 )
 from pandas._libs.tslibs.dtypes import abbrev_to_npy_unit
-from pandas._libs.tslibs.offsets import prefix_mapping
+from pandas._libs.tslibs.offsets import (
+    DateOffset,
+    prefix_mapping,
+)
 from pandas.errors import Pandas4Warning
 from pandas.util._decorators import (
     cache_readonly,
@@ -1064,6 +1067,12 @@ def date_range(
     """
     if freq is None and com.any_none(periods, start, end):
         freq = "D"
+    if freq is not None:
+        freq = to_offset(freq)
+
+    if start is NaT or end is NaT:
+        # This check needs to come before the `unit = start.unit` line below
+        raise ValueError("Neither `start` nor `end` can be NaT")
 
     if unit is None:
         # Infer the unit based on the inputs
@@ -1078,14 +1087,18 @@ def date_range(
         elif start is not None:
             start = Timestamp(start)
             unit = start.unit
-        else:
+        elif end is not None:
             end = Timestamp(end)
             unit = end.unit
+        else:
+            raise ValueError(
+                "Of the four parameters: start, end, periods, "
+                "and freq, exactly three must be specified"
+            )
 
         # Last we need to watch out for cases where the 'freq' implies a higher
         #  unit than either start or end
         if freq is not None:
-            freq = to_offset(freq)
             creso = abbrev_to_npy_unit(unit)
             if isinstance(freq, Tick):
                 if freq._creso > creso:
@@ -1095,6 +1108,9 @@ def date_range(
                 td = Timedelta(freq.offset)
                 if abbrev_to_npy_unit(td.unit) > creso:
                     unit = td.unit
+            elif type(freq) is DateOffset and getattr(freq, "nanoseconds", 0) != 0:
+                # e.g. test_freq_dateoffset_with_relateivedelta_nanos
+                unit = "ns"
 
     dtarr = DatetimeArray._generate_range(
         start=start,

pandas/tests/indexes/datetimes/test_date_range.py

@@ -242,11 +242,11 @@ def test_date_range_int64_overflow_non_recoverable(self):
         # case with start later than 1970-01-01, overflow int64 but not uint64
         msg = "Cannot generate range with"
         with pytest.raises(OutOfBoundsDatetime, match=msg):
-            date_range(start="1970-02-01", periods=106752 * 24, freq="h")
+            date_range(start="1970-02-01", periods=106752 * 24, freq="h", unit="ns")
 
         # case with end before 1970-01-01, overflow int64 but not uint64
         with pytest.raises(OutOfBoundsDatetime, match=msg):
-            date_range(end="1969-11-14", periods=106752 * 24, freq="h")
+            date_range(end="1969-11-14", periods=106752 * 24, freq="h", unit="ns")
 
     @pytest.mark.slow
     @pytest.mark.parametrize(
@@ -271,9 +271,9 @@ def test_date_range_out_of_bounds(self):
         # GH#14187
         msg = "Cannot generate range"
         with pytest.raises(OutOfBoundsDatetime, match=msg):
-            date_range("2016-01-01", periods=100000, freq="D")
+            date_range("2016-01-01", periods=100000, freq="D", unit="ns")
         with pytest.raises(OutOfBoundsDatetime, match=msg):
-            date_range(end="1763-10-12", periods=100000, freq="D")
+            date_range(end="1763-10-12", periods=100000, freq="D", unit="ns")
 
     def test_date_range_gen_error(self):
         rng = date_range("1/1/2000 00:00", "1/1/2000 00:18", freq="5min")
@@ -287,7 +287,7 @@ def test_date_range_normalize(self):
 
         offset = timedelta(2)
         expected = DatetimeIndex(
-            [snap + i * offset for i in range(n)], dtype="M8[ns]", freq=offset
+            [snap + i * offset for i in range(n)], dtype="M8[us]", freq=offset
         )
 
         tm.assert_index_equal(rng, expected)
@@ -687,13 +687,13 @@ def test_freq_divides_end_in_nanos(self):
         result_2 = date_range("2005-01-13 10:00", "2005-01-13 16:00", freq="345min")
         expected_1 = DatetimeIndex(
             ["2005-01-12 10:00:00", "2005-01-12 15:45:00"],
-            dtype="datetime64[ns]",
+            dtype="datetime64[us]",
             freq="345min",
             tz=None,
         )
         expected_2 = DatetimeIndex(
             ["2005-01-13 10:00:00", "2005-01-13 15:45:00"],
-            dtype="datetime64[ns]",
+            dtype="datetime64[us]",
             freq="345min",
             tz=None,
         )
@@ -1014,10 +1014,10 @@ def test_precision_finer_than_offset(self):
             "2015-06-21 00:00:03",
         ]
         expected1 = DatetimeIndex(
-            expected1_list, dtype="datetime64[ns]", freq="QE-DEC", tz=None
+            expected1_list, dtype="datetime64[us]", freq="QE-DEC", tz=None
         )
         expected2 = DatetimeIndex(
-            expected2_list, dtype="datetime64[ns]", freq="W-SUN", tz=None
+            expected2_list, dtype="datetime64[us]", freq="W-SUN", tz=None
         )
         tm.assert_index_equal(result1, expected1)
         tm.assert_index_equal(result2, expected2)
@@ -1110,15 +1110,15 @@ def test_bday_near_overflow(self):
         # GH#24252 avoid doing unnecessary addition that _would_ overflow
         start = Timestamp.max.floor("D").to_pydatetime()
         rng = date_range(start, end=None, periods=1, freq="B")
-        expected = DatetimeIndex([start], freq="B").as_unit("ns")
+        expected = DatetimeIndex([start], freq="B")
         tm.assert_index_equal(rng, expected)
 
     def test_bday_overflow_error(self):
         # GH#24252 check that we get OutOfBoundsDatetime and not OverflowError
         msg = "Out of bounds nanosecond timestamp"
         start = Timestamp.max.floor("D").to_pydatetime()
         with pytest.raises(OutOfBoundsDatetime, match=msg):
-            date_range(start, periods=2, freq="B")
+            date_range(start, periods=2, freq="B", unit="ns")
 
 
 class TestCustomDateRange:
@@ -1257,7 +1257,7 @@ def test_range_with_millisecond_resolution(self, start_end):
         # https://github.com/pandas-dev/pandas/issues/24110
         start, end = start_end
         result = date_range(start=start, end=end, periods=2, inclusive="left")
-        expected = DatetimeIndex([start], dtype="M8[ns, UTC]")
+        expected = DatetimeIndex([start], dtype="M8[us, UTC]")
         tm.assert_index_equal(result, expected)
 
     @pytest.mark.parametrize(
@@ -1275,7 +1275,7 @@ def test_range_with_millisecond_resolution(self, start_end):
     def test_range_with_timezone_and_custombusinessday(self, start, period, expected):
         # GH49441
         result = date_range(start=start, periods=period, freq="C")
-        expected = DatetimeIndex(expected).as_unit("ns")
+        expected = DatetimeIndex(expected).as_unit("us")
         tm.assert_index_equal(result, expected)
 
     def test_data_range_custombusinessday_partial_time(self, unit):
@@ -1316,7 +1316,7 @@ def test_cdaterange_cbh(self):
                 "2009-03-13 15:00:00",
                 "2009-03-13 16:00:00",
             ],
-            dtype="datetime64[ns]",
+            dtype="datetime64[us]",
             freq="cbh",
         )
         tm.assert_index_equal(result, expected)

pandas/tests/indexes/interval/test_astype.py

@@ -221,7 +221,8 @@ def test_subtype_integer(self, index, subtype):
 
         if subtype != "int64":
             msg = (
-                r"Cannot convert interval\[(timedelta64|datetime64)\[ns.*\], .*\] "
+                r"Cannot convert interval"
+                r"\[(timedelta64\[ns\]|datetime64\[us(, US/Eastern)?\]), .*\] "
                 r"to interval\[uint64, .*\]"
             )
             with pytest.raises(TypeError, match=msg):

pandas/tests/indexes/interval/test_interval.py

@@ -81,7 +81,7 @@ def test_properties(self, closed):
         [
             [1, 1, 2, 5, 15, 53, 217, 1014, 5335, 31240, 201608],
             [-np.inf, -100, -10, 0.5, 1, 1.5, 3.8, 101, 202, np.inf],
-            date_range("2017-01-01", "2017-01-04"),
+            date_range("2017-01-01", "2017-01-04", unit="ns"),
             pytest.param(
                 date_range("2017-01-01", "2017-01-04", unit="s"),
                 marks=pytest.mark.xfail(reason="mismatched result unit"),
@@ -377,13 +377,16 @@ def test_maybe_convert_i8(self, breaks):
 
     @pytest.mark.parametrize(
         "breaks",
-        [date_range("2018-01-01", periods=5), timedelta_range("0 days", periods=5)],
+        [
+            date_range("2018-01-01", periods=5),
+            timedelta_range("0 days", periods=5, unit="us"),
+        ],
     )
     def test_maybe_convert_i8_nat(self, breaks):
         # GH 20636
         index = IntervalIndex.from_breaks(breaks)
 
-        to_convert = breaks._constructor([pd.NaT] * 3).as_unit("ns")
+        to_convert = breaks._constructor([pd.NaT] * 3).as_unit("us")
         expected = Index([np.nan] * 3, dtype=np.float64)
         result = index._maybe_convert_i8(to_convert)
         tm.assert_index_equal(result, expected)

pandas/tests/indexes/interval/test_interval_range.py

@@ -265,7 +265,7 @@ def test_constructor_coverage(self):
             tm.assert_index_equal(result, expected)
 
         # equivalent timedelta-like start/end
-        start, end = Timedelta(days=1), Timedelta(days=10)
+        start, end = Timedelta(days=1).as_unit("us"), Timedelta(days=10).as_unit("us")
         expected = interval_range(start=start, end=end)
 
         result = interval_range(start=start.to_pytimedelta(), end=end.to_pytimedelta())

pandas/tests/reshape/test_cut.py

@@ -794,7 +794,7 @@ def test_cut_bins_datetime_intervalindex():
     # https://github.com/pandas-dev/pandas/issues/46218
     bins = interval_range(Timestamp("2022-02-25"), Timestamp("2022-02-27"), freq="1D")
     # passing Series instead of list is important to trigger bug
-    result = cut(Series([Timestamp("2022-02-26")]).astype("M8[ns]"), bins=bins)
+    result = cut(Series([Timestamp("2022-02-26")]), bins=bins)
     expected = Categorical.from_codes([0], bins, ordered=True)
     tm.assert_categorical_equal(result.array, expected)
 

pandas/tests/tseries/holiday/test_federal.py

@@ -50,7 +50,7 @@ def test_federal_holiday_inconsistent_returntype():
 
     results_2018 = cal1.holidays(start=datetime(2018, 8, 1), end=datetime(2018, 8, 31))
     results_2019 = cal2.holidays(start=datetime(2019, 8, 1), end=datetime(2019, 8, 31))
-    expected_results = DatetimeIndex([], dtype="datetime64[ns]", freq=None)
+    expected_results = DatetimeIndex([], dtype="datetime64[us]", freq=None)
 
     # Check against expected results to ensure both date
     # ranges generate expected results as per GH49075 submission

pandas/tests/tseries/holiday/test_holiday.py

@@ -328,7 +328,7 @@ class TestHolidayCalendar(AbstractHolidayCalendar):
     start = Timestamp("2022-08-01")
     end = Timestamp("2022-08-31")
     year_offset = DateOffset(years=5)
-    expected_results = DatetimeIndex([], dtype="datetime64[ns]", freq=None)
+    expected_results = DatetimeIndex([], dtype="datetime64[us]", freq=None)
     test_cal = TestHolidayCalendar()
 
     date_interval_low = test_cal.holidays(start - year_offset, end - year_offset)
@@ -350,7 +350,6 @@ def test_holidays_with_timezone_specified_but_no_occurrences():
         start_date, end_date, return_name=True
     )
     expected_results = Series("New Year's Day", index=[start_date])
-    expected_results.index = expected_results.index.as_unit("ns")
 
     tm.assert_equal(test_case, expected_results)
 
@@ -378,7 +377,7 @@ def test_holiday_with_exclusion():
             Timestamp("2024-05-27"),
             Timestamp("2025-05-26"),
         ],
-        dtype="datetime64[ns]",
+        dtype="datetime64[us]",
     )
     tm.assert_index_equal(result, expected)
 
@@ -440,7 +439,7 @@ def test_holiday_with_multiple_exclusions():
             Timestamp("2064-01-01"),
             Timestamp("2065-01-01"),
         ],
-        dtype="datetime64[s]",
+        dtype="datetime64[us]",
     )
     tm.assert_index_equal(result, expected)