def test_nanosecond_timestamp(self): # GH 7610 expected = 1_293_840_000_000_000_005 t = Timestamp("2011-01-01") + offsets.Nano(5) assert repr(t) == "Timestamp('2011-01-01 00:00:00.000000005')" assert t.value == expected assert t.nanosecond == 5 t = Timestamp(t) assert repr(t) == "Timestamp('2011-01-01 00:00:00.000000005')" assert t.value == expected assert t.nanosecond == 5 t = Timestamp(np_datetime64_compat("2011-01-01 00:00:00.000000005Z")) assert repr(t) == "Timestamp('2011-01-01 00:00:00.000000005')" assert t.value == expected assert t.nanosecond == 5 expected = 1_293_840_000_000_000_010 t = t + offsets.Nano(5) assert repr(t) == "Timestamp('2011-01-01 00:00:00.000000010')" assert t.value == expected assert t.nanosecond == 10 t = Timestamp(t) assert repr(t) == "Timestamp('2011-01-01 00:00:00.000000010')" assert t.value == expected assert t.nanosecond == 10 t = Timestamp(np_datetime64_compat("2011-01-01 00:00:00.000000010Z")) assert repr(t) == "Timestamp('2011-01-01 00:00:00.000000010')" assert t.value == expected assert t.nanosecond == 10
def test_conversion(self): rs = self.dtc.convert(["2012-1-1"], None, None)[0] xp = dates.date2num(datetime(2012, 1, 1)) assert rs == xp rs = self.dtc.convert("2012-1-1", None, None) assert rs == xp rs = self.dtc.convert(date(2012, 1, 1), None, None) assert rs == xp rs = self.dtc.convert("2012-1-1", None, None) assert rs == xp rs = self.dtc.convert(Timestamp("2012-1-1"), None, None) assert rs == xp # also testing datetime64 dtype (GH8614) rs = self.dtc.convert(np_datetime64_compat("2012-01-01"), None, None) assert rs == xp rs = self.dtc.convert(np_datetime64_compat("2012-01-01 00:00:00+0000"), None, None) assert rs == xp rs = self.dtc.convert( np.array([ np_datetime64_compat("2012-01-01 00:00:00+0000"), np_datetime64_compat("2012-01-02 00:00:00+0000"), ]), None, None, ) assert rs[0] == xp # we have a tz-aware date (constructed to that when we turn to utc it # is the same as our sample) ts = Timestamp("2012-01-01").tz_localize("UTC").tz_convert( "US/Eastern") rs = self.dtc.convert(ts, None, None) assert rs == xp rs = self.dtc.convert(ts.to_pydatetime(), None, None) assert rs == xp rs = self.dtc.convert(Index([ts - Day(1), ts]), None, None) assert rs[1] == xp rs = self.dtc.convert( Index([ts - Day(1), ts]).to_pydatetime(), None, None) assert rs[1] == xp
def setup_method(self, method): self.d = datetime(2008, 1, 1) self.nd = np_datetime64_compat("2008-01-01 00:00:00Z") self.offset = CDay() self.offset1 = self.offset self.offset2 = CDay(2)
def test_rollforward(self, offset_types): expecteds = self.expecteds.copy() # result will not be changed if the target is on the offset no_changes = [ "Day", "MonthBegin", "SemiMonthBegin", "YearBegin", "Week", "Hour", "Minute", "Second", "Milli", "Micro", "Nano", "DateOffset", ] for n in no_changes: expecteds[n] = Timestamp("2011/01/01 09:00") expecteds["BusinessHour"] = Timestamp("2011-01-03 09:00:00") expecteds["CustomBusinessHour"] = Timestamp("2011-01-03 09:00:00") # but be changed when normalize=True norm_expected = expecteds.copy() for k in norm_expected: norm_expected[k] = Timestamp(norm_expected[k].date()) normalized = { "Day": Timestamp("2011-01-02 00:00:00"), "DateOffset": Timestamp("2011-01-02 00:00:00"), "MonthBegin": Timestamp("2011-02-01 00:00:00"), "SemiMonthBegin": Timestamp("2011-01-15 00:00:00"), "YearBegin": Timestamp("2012-01-01 00:00:00"), "Week": Timestamp("2011-01-08 00:00:00"), "Hour": Timestamp("2011-01-01 00:00:00"), "Minute": Timestamp("2011-01-01 00:00:00"), "Second": Timestamp("2011-01-01 00:00:00"), "Milli": Timestamp("2011-01-01 00:00:00"), "Micro": Timestamp("2011-01-01 00:00:00"), } norm_expected.update(normalized) sdt = datetime(2011, 1, 1, 9, 0) ndt = np_datetime64_compat("2011-01-01 09:00Z") for dt in [sdt, ndt]: expected = expecteds[offset_types.__name__] self._check_offsetfunc_works(offset_types, "rollforward", dt, expected) expected = norm_expected[offset_types.__name__] self._check_offsetfunc_works(offset_types, "rollforward", dt, expected, normalize=True)
def test_apply(self, offset_types): sdt = datetime(2011, 1, 1, 9, 0) ndt = np_datetime64_compat("2011-01-01 09:00Z") for dt in [sdt, ndt]: expected = self.expecteds[offset_types.__name__] self._check_offsetfunc_works(offset_types, "apply", dt, expected) expected = Timestamp(expected.date()) self._check_offsetfunc_works( offset_types, "apply", dt, expected, normalize=True )
def test_asof_nanosecond_index_access(self): ts = Timestamp("20130101").value dti = DatetimeIndex([ts + 50 + i for i in range(100)]) ser = Series(np.random.randn(100), index=dti) first_value = ser.asof(ser.index[0]) # this used to not work bc parsing was done by dateutil that didn't # handle nanoseconds assert first_value == ser["2013-01-01 00:00:00.000000050+0000"] expected_ts = np_datetime64_compat( "2013-01-01 00:00:00.000000050+0000", "ns") assert first_value == ser[Timestamp(expected_ts)]
def test_conversion(self): rs = self.pc.convert(["2012-1-1"], None, self.axis)[0] xp = Period("2012-1-1").ordinal assert rs == xp rs = self.pc.convert("2012-1-1", None, self.axis) assert rs == xp rs = self.pc.convert([date(2012, 1, 1)], None, self.axis)[0] assert rs == xp rs = self.pc.convert(date(2012, 1, 1), None, self.axis) assert rs == xp rs = self.pc.convert([Timestamp("2012-1-1")], None, self.axis)[0] assert rs == xp rs = self.pc.convert(Timestamp("2012-1-1"), None, self.axis) assert rs == xp rs = self.pc.convert(np_datetime64_compat("2012-01-01"), None, self.axis) assert rs == xp rs = self.pc.convert(np_datetime64_compat("2012-01-01 00:00:00+0000"), None, self.axis) assert rs == xp rs = self.pc.convert( np.array([ np_datetime64_compat("2012-01-01 00:00:00+0000"), np_datetime64_compat("2012-01-02 00:00:00+0000"), ]), None, self.axis, ) assert rs[0] == xp
class TestCommon(Base): # executed value created by Base._get_offset # are applied to 2011/01/01 09:00 (Saturday) # used for .apply and .rollforward expecteds = { "Day": Timestamp("2011-01-02 09:00:00"), "DateOffset": Timestamp("2011-01-02 09:00:00"), "BusinessDay": Timestamp("2011-01-03 09:00:00"), "CustomBusinessDay": Timestamp("2011-01-03 09:00:00"), "CustomBusinessMonthEnd": Timestamp("2011-01-31 09:00:00"), "CustomBusinessMonthBegin": Timestamp("2011-01-03 09:00:00"), "MonthBegin": Timestamp("2011-02-01 09:00:00"), "BusinessMonthBegin": Timestamp("2011-01-03 09:00:00"), "MonthEnd": Timestamp("2011-01-31 09:00:00"), "SemiMonthEnd": Timestamp("2011-01-15 09:00:00"), "SemiMonthBegin": Timestamp("2011-01-15 09:00:00"), "BusinessMonthEnd": Timestamp("2011-01-31 09:00:00"), "YearBegin": Timestamp("2012-01-01 09:00:00"), "BYearBegin": Timestamp("2011-01-03 09:00:00"), "YearEnd": Timestamp("2011-12-31 09:00:00"), "BYearEnd": Timestamp("2011-12-30 09:00:00"), "QuarterBegin": Timestamp("2011-03-01 09:00:00"), "BQuarterBegin": Timestamp("2011-03-01 09:00:00"), "QuarterEnd": Timestamp("2011-03-31 09:00:00"), "BQuarterEnd": Timestamp("2011-03-31 09:00:00"), "BusinessHour": Timestamp("2011-01-03 10:00:00"), "CustomBusinessHour": Timestamp("2011-01-03 10:00:00"), "WeekOfMonth": Timestamp("2011-01-08 09:00:00"), "LastWeekOfMonth": Timestamp("2011-01-29 09:00:00"), "FY5253Quarter": Timestamp("2011-01-25 09:00:00"), "FY5253": Timestamp("2011-01-25 09:00:00"), "Week": Timestamp("2011-01-08 09:00:00"), "Easter": Timestamp("2011-04-24 09:00:00"), "Hour": Timestamp("2011-01-01 10:00:00"), "Minute": Timestamp("2011-01-01 09:01:00"), "Second": Timestamp("2011-01-01 09:00:01"), "Milli": Timestamp("2011-01-01 09:00:00.001000"), "Micro": Timestamp("2011-01-01 09:00:00.000001"), "Nano": Timestamp(np_datetime64_compat("2011-01-01T09:00:00.000000001Z")), } def test_immutable(self, offset_types): # GH#21341 check that __setattr__ raises offset = self._get_offset(offset_types) msg = "objects is not writable|DateOffset objects are immutable" with pytest.raises(AttributeError, match=msg): offset.normalize = True with pytest.raises(AttributeError, match=msg): offset.n = 91 def test_return_type(self, offset_types): offset = self._get_offset(offset_types) # make sure that we are returning a Timestamp result = Timestamp("20080101") + offset assert isinstance(result, Timestamp) # make sure that we are returning NaT assert NaT + offset is NaT assert offset + NaT is NaT assert NaT - offset is NaT assert (-offset)._apply(NaT) is NaT def test_offset_n(self, offset_types): offset = self._get_offset(offset_types) assert offset.n == 1 neg_offset = offset * -1 assert neg_offset.n == -1 mul_offset = offset * 3 assert mul_offset.n == 3 def test_offset_timedelta64_arg(self, offset_types): # check that offset._validate_n raises TypeError on a timedelt64 # object off = self._get_offset(offset_types) td64 = np.timedelta64(4567, "s") with pytest.raises(TypeError, match="argument must be an integer"): type(off)(n=td64, **off.kwds) def test_offset_mul_ndarray(self, offset_types): off = self._get_offset(offset_types) expected = np.array([[off, off * 2], [off * 3, off * 4]]) result = np.array([[1, 2], [3, 4]]) * off tm.assert_numpy_array_equal(result, expected) result = off * np.array([[1, 2], [3, 4]]) tm.assert_numpy_array_equal(result, expected) def test_offset_freqstr(self, offset_types): offset = self._get_offset(offset_types) freqstr = offset.freqstr if freqstr not in ("<Easter>", "<DateOffset: days=1>", "LWOM-SAT"): code = _get_offset(freqstr) assert offset.rule_code == code def _check_offsetfunc_works(self, offset, funcname, dt, expected, normalize=False): if normalize and issubclass(offset, Tick): # normalize=True disallowed for Tick subclasses GH#21427 return offset_s = self._get_offset(offset, normalize=normalize) func = getattr(offset_s, funcname) result = func(dt) assert isinstance(result, Timestamp) assert result == expected result = func(Timestamp(dt)) assert isinstance(result, Timestamp) assert result == expected # see gh-14101 exp_warning = None ts = Timestamp(dt) + Nano(5) if (type(offset_s).__name__ == "DateOffset" and (funcname in ["apply", "_apply"] or normalize) and ts.nanosecond > 0): exp_warning = UserWarning # test nanosecond is preserved with tm.assert_produces_warning(exp_warning): result = func(ts) if exp_warning is None and funcname == "_apply": # GH#44522 # Check in this particular case to avoid headaches with # testing for multiple warnings produced by the same call. with tm.assert_produces_warning(FutureWarning, match="apply is deprecated"): res2 = offset_s.apply(ts) assert type(res2) is type(result) assert res2 == result assert isinstance(result, Timestamp) if normalize is False: assert result == expected + Nano(5) else: assert result == expected if isinstance(dt, np.datetime64): # test tz when input is datetime or Timestamp return for tz in self.timezones: expected_localize = expected.tz_localize(tz) tz_obj = timezones.maybe_get_tz(tz) dt_tz = conversion.localize_pydatetime(dt, tz_obj) result = func(dt_tz) assert isinstance(result, Timestamp) assert result == expected_localize result = func(Timestamp(dt, tz=tz)) assert isinstance(result, Timestamp) assert result == expected_localize # see gh-14101 exp_warning = None ts = Timestamp(dt, tz=tz) + Nano(5) if (type(offset_s).__name__ == "DateOffset" and (funcname in ["apply", "_apply"] or normalize) and ts.nanosecond > 0): exp_warning = UserWarning # test nanosecond is preserved with tm.assert_produces_warning(exp_warning): result = func(ts) assert isinstance(result, Timestamp) if normalize is False: assert result == expected_localize + Nano(5) else: assert result == expected_localize def test_apply(self, offset_types): sdt = datetime(2011, 1, 1, 9, 0) ndt = np_datetime64_compat("2011-01-01 09:00Z") expected = self.expecteds[offset_types.__name__] expected_norm = Timestamp(expected.date()) for dt in [sdt, ndt]: self._check_offsetfunc_works(offset_types, "_apply", dt, expected) self._check_offsetfunc_works(offset_types, "_apply", dt, expected_norm, normalize=True) def test_rollforward(self, offset_types): expecteds = self.expecteds.copy() # result will not be changed if the target is on the offset no_changes = [ "Day", "MonthBegin", "SemiMonthBegin", "YearBegin", "Week", "Hour", "Minute", "Second", "Milli", "Micro", "Nano", "DateOffset", ] for n in no_changes: expecteds[n] = Timestamp("2011/01/01 09:00") expecteds["BusinessHour"] = Timestamp("2011-01-03 09:00:00") expecteds["CustomBusinessHour"] = Timestamp("2011-01-03 09:00:00") # but be changed when normalize=True norm_expected = expecteds.copy() for k in norm_expected: norm_expected[k] = Timestamp(norm_expected[k].date()) normalized = { "Day": Timestamp("2011-01-02 00:00:00"), "DateOffset": Timestamp("2011-01-02 00:00:00"), "MonthBegin": Timestamp("2011-02-01 00:00:00"), "SemiMonthBegin": Timestamp("2011-01-15 00:00:00"), "YearBegin": Timestamp("2012-01-01 00:00:00"), "Week": Timestamp("2011-01-08 00:00:00"), "Hour": Timestamp("2011-01-01 00:00:00"), "Minute": Timestamp("2011-01-01 00:00:00"), "Second": Timestamp("2011-01-01 00:00:00"), "Milli": Timestamp("2011-01-01 00:00:00"), "Micro": Timestamp("2011-01-01 00:00:00"), } norm_expected.update(normalized) sdt = datetime(2011, 1, 1, 9, 0) ndt = np_datetime64_compat("2011-01-01 09:00Z") for dt in [sdt, ndt]: expected = expecteds[offset_types.__name__] self._check_offsetfunc_works(offset_types, "rollforward", dt, expected) expected = norm_expected[offset_types.__name__] self._check_offsetfunc_works(offset_types, "rollforward", dt, expected, normalize=True) def test_rollback(self, offset_types): expecteds = { "BusinessDay": Timestamp("2010-12-31 09:00:00"), "CustomBusinessDay": Timestamp("2010-12-31 09:00:00"), "CustomBusinessMonthEnd": Timestamp("2010-12-31 09:00:00"), "CustomBusinessMonthBegin": Timestamp("2010-12-01 09:00:00"), "BusinessMonthBegin": Timestamp("2010-12-01 09:00:00"), "MonthEnd": Timestamp("2010-12-31 09:00:00"), "SemiMonthEnd": Timestamp("2010-12-31 09:00:00"), "BusinessMonthEnd": Timestamp("2010-12-31 09:00:00"), "BYearBegin": Timestamp("2010-01-01 09:00:00"), "YearEnd": Timestamp("2010-12-31 09:00:00"), "BYearEnd": Timestamp("2010-12-31 09:00:00"), "QuarterBegin": Timestamp("2010-12-01 09:00:00"), "BQuarterBegin": Timestamp("2010-12-01 09:00:00"), "QuarterEnd": Timestamp("2010-12-31 09:00:00"), "BQuarterEnd": Timestamp("2010-12-31 09:00:00"), "BusinessHour": Timestamp("2010-12-31 17:00:00"), "CustomBusinessHour": Timestamp("2010-12-31 17:00:00"), "WeekOfMonth": Timestamp("2010-12-11 09:00:00"), "LastWeekOfMonth": Timestamp("2010-12-25 09:00:00"), "FY5253Quarter": Timestamp("2010-10-26 09:00:00"), "FY5253": Timestamp("2010-01-26 09:00:00"), "Easter": Timestamp("2010-04-04 09:00:00"), } # result will not be changed if the target is on the offset for n in [ "Day", "MonthBegin", "SemiMonthBegin", "YearBegin", "Week", "Hour", "Minute", "Second", "Milli", "Micro", "Nano", "DateOffset", ]: expecteds[n] = Timestamp("2011/01/01 09:00") # but be changed when normalize=True norm_expected = expecteds.copy() for k in norm_expected: norm_expected[k] = Timestamp(norm_expected[k].date()) normalized = { "Day": Timestamp("2010-12-31 00:00:00"), "DateOffset": Timestamp("2010-12-31 00:00:00"), "MonthBegin": Timestamp("2010-12-01 00:00:00"), "SemiMonthBegin": Timestamp("2010-12-15 00:00:00"), "YearBegin": Timestamp("2010-01-01 00:00:00"), "Week": Timestamp("2010-12-25 00:00:00"), "Hour": Timestamp("2011-01-01 00:00:00"), "Minute": Timestamp("2011-01-01 00:00:00"), "Second": Timestamp("2011-01-01 00:00:00"), "Milli": Timestamp("2011-01-01 00:00:00"), "Micro": Timestamp("2011-01-01 00:00:00"), } norm_expected.update(normalized) sdt = datetime(2011, 1, 1, 9, 0) ndt = np_datetime64_compat("2011-01-01 09:00Z") for dt in [sdt, ndt]: expected = expecteds[offset_types.__name__] self._check_offsetfunc_works(offset_types, "rollback", dt, expected) expected = norm_expected[offset_types.__name__] self._check_offsetfunc_works(offset_types, "rollback", dt, expected, normalize=True) def test_is_on_offset(self, offset_types): dt = self.expecteds[offset_types.__name__] offset_s = self._get_offset(offset_types) assert offset_s.is_on_offset(dt) # when normalize=True, is_on_offset checks time is 00:00:00 if issubclass(offset_types, Tick): # normalize=True disallowed for Tick subclasses GH#21427 return offset_n = self._get_offset(offset_types, normalize=True) assert not offset_n.is_on_offset(dt) if offset_types in (BusinessHour, CustomBusinessHour): # In default BusinessHour (9:00-17:00), normalized time # cannot be in business hour range return date = datetime(dt.year, dt.month, dt.day) assert offset_n.is_on_offset(date) def test_add(self, offset_types, tz_naive_fixture): tz = tz_naive_fixture dt = datetime(2011, 1, 1, 9, 0) offset_s = self._get_offset(offset_types) expected = self.expecteds[offset_types.__name__] result_dt = dt + offset_s result_ts = Timestamp(dt) + offset_s for result in [result_dt, result_ts]: assert isinstance(result, Timestamp) assert result == expected expected_localize = expected.tz_localize(tz) result = Timestamp(dt, tz=tz) + offset_s assert isinstance(result, Timestamp) assert result == expected_localize # normalize=True, disallowed for Tick subclasses GH#21427 if issubclass(offset_types, Tick): return offset_s = self._get_offset(offset_types, normalize=True) expected = Timestamp(expected.date()) result_dt = dt + offset_s result_ts = Timestamp(dt) + offset_s for result in [result_dt, result_ts]: assert isinstance(result, Timestamp) assert result == expected expected_localize = expected.tz_localize(tz) result = Timestamp(dt, tz=tz) + offset_s assert isinstance(result, Timestamp) assert result == expected_localize def test_add_empty_datetimeindex(self, offset_types, tz_naive_fixture): # GH#12724, GH#30336 offset_s = self._get_offset(offset_types) dti = DatetimeIndex([], tz=tz_naive_fixture) warn = None if isinstance( offset_s, ( Easter, WeekOfMonth, LastWeekOfMonth, CustomBusinessDay, BusinessHour, CustomBusinessHour, CustomBusinessMonthBegin, CustomBusinessMonthEnd, FY5253, FY5253Quarter, ), ): # We don't have an optimized apply_index warn = PerformanceWarning with tm.assert_produces_warning(warn): result = dti + offset_s tm.assert_index_equal(result, dti) with tm.assert_produces_warning(warn): result = offset_s + dti tm.assert_index_equal(result, dti) dta = dti._data with tm.assert_produces_warning(warn): result = dta + offset_s tm.assert_equal(result, dta) with tm.assert_produces_warning(warn): result = offset_s + dta tm.assert_equal(result, dta) def test_pickle_roundtrip(self, offset_types): off = self._get_offset(offset_types) res = tm.round_trip_pickle(off) assert off == res if type(off) is not DateOffset: for attr in off._attributes: if attr == "calendar": # np.busdaycalendar __eq__ will return False; # we check holidays and weekmask attrs so are OK continue # Make sure nothings got lost from _params (which __eq__) is based on assert getattr(off, attr) == getattr(res, attr) def test_pickle_dateoffset_odd_inputs(self): # GH#34511 off = DateOffset(months=12) res = tm.round_trip_pickle(off) assert off == res base_dt = datetime(2020, 1, 1) assert base_dt + off == base_dt + res def test_onOffset_deprecated(self, offset_types, fixed_now_ts): # GH#30340 use idiomatic naming off = self._get_offset(offset_types) ts = fixed_now_ts with tm.assert_produces_warning(FutureWarning): result = off.onOffset(ts) expected = off.is_on_offset(ts) assert result == expected def test_isAnchored_deprecated(self, offset_types): # GH#30340 use idiomatic naming off = self._get_offset(offset_types) with tm.assert_produces_warning(FutureWarning): result = off.isAnchored() expected = off.is_anchored() assert result == expected def test_offsets_hashable(self, offset_types): # GH: 37267 off = self._get_offset(offset_types) assert hash(off) is not None
def test_rollback(self, offset_types): expecteds = { "BusinessDay": Timestamp("2010-12-31 09:00:00"), "CustomBusinessDay": Timestamp("2010-12-31 09:00:00"), "CustomBusinessMonthEnd": Timestamp("2010-12-31 09:00:00"), "CustomBusinessMonthBegin": Timestamp("2010-12-01 09:00:00"), "BusinessMonthBegin": Timestamp("2010-12-01 09:00:00"), "MonthEnd": Timestamp("2010-12-31 09:00:00"), "SemiMonthEnd": Timestamp("2010-12-31 09:00:00"), "BusinessMonthEnd": Timestamp("2010-12-31 09:00:00"), "BYearBegin": Timestamp("2010-01-01 09:00:00"), "YearEnd": Timestamp("2010-12-31 09:00:00"), "BYearEnd": Timestamp("2010-12-31 09:00:00"), "QuarterBegin": Timestamp("2010-12-01 09:00:00"), "BQuarterBegin": Timestamp("2010-12-01 09:00:00"), "QuarterEnd": Timestamp("2010-12-31 09:00:00"), "BQuarterEnd": Timestamp("2010-12-31 09:00:00"), "BusinessHour": Timestamp("2010-12-31 17:00:00"), "CustomBusinessHour": Timestamp("2010-12-31 17:00:00"), "WeekOfMonth": Timestamp("2010-12-11 09:00:00"), "LastWeekOfMonth": Timestamp("2010-12-25 09:00:00"), "FY5253Quarter": Timestamp("2010-10-26 09:00:00"), "FY5253": Timestamp("2010-01-26 09:00:00"), "Easter": Timestamp("2010-04-04 09:00:00"), } # result will not be changed if the target is on the offset for n in [ "Day", "MonthBegin", "SemiMonthBegin", "YearBegin", "Week", "Hour", "Minute", "Second", "Milli", "Micro", "Nano", "DateOffset", ]: expecteds[n] = Timestamp("2011/01/01 09:00") # but be changed when normalize=True norm_expected = expecteds.copy() for k in norm_expected: norm_expected[k] = Timestamp(norm_expected[k].date()) normalized = { "Day": Timestamp("2010-12-31 00:00:00"), "DateOffset": Timestamp("2010-12-31 00:00:00"), "MonthBegin": Timestamp("2010-12-01 00:00:00"), "SemiMonthBegin": Timestamp("2010-12-15 00:00:00"), "YearBegin": Timestamp("2010-01-01 00:00:00"), "Week": Timestamp("2010-12-25 00:00:00"), "Hour": Timestamp("2011-01-01 00:00:00"), "Minute": Timestamp("2011-01-01 00:00:00"), "Second": Timestamp("2011-01-01 00:00:00"), "Milli": Timestamp("2011-01-01 00:00:00"), "Micro": Timestamp("2011-01-01 00:00:00"), } norm_expected.update(normalized) sdt = datetime(2011, 1, 1, 9, 0) ndt = np_datetime64_compat("2011-01-01 09:00Z") for dt in [sdt, ndt]: expected = expecteds[offset_types.__name__] self._check_offsetfunc_works(offset_types, "rollback", dt, expected) expected = norm_expected[offset_types.__name__] self._check_offsetfunc_works(offset_types, "rollback", dt, expected, normalize=True)
class TestDtypeEnforced: # check we don't silently ignore the dtype keyword @pytest.mark.parametrize("dtype", [object, "float64", "uint64", "category"]) def test_constructor_range_values_mismatched_dtype(self, dtype): rng = Index(range(5)) result = Index(rng, dtype=dtype) assert result.dtype == dtype result = Index(range(5), dtype=dtype) assert result.dtype == dtype @pytest.mark.parametrize("dtype", [object, "float64", "uint64", "category"]) def test_constructor_categorical_values_mismatched_non_ea_dtype( self, dtype): cat = Categorical([1, 2, 3]) result = Index(cat, dtype=dtype) assert result.dtype == dtype def test_constructor_categorical_values_mismatched_dtype(self): dti = date_range("2016-01-01", periods=3) cat = Categorical(dti) result = Index(cat, dti.dtype) tm.assert_index_equal(result, dti) dti2 = dti.tz_localize("Asia/Tokyo") cat2 = Categorical(dti2) result = Index(cat2, dti2.dtype) tm.assert_index_equal(result, dti2) ii = IntervalIndex.from_breaks(range(5)) cat3 = Categorical(ii) result = Index(cat3, dtype=ii.dtype) tm.assert_index_equal(result, ii) def test_constructor_ea_values_mismatched_categorical_dtype(self): dti = date_range("2016-01-01", periods=3) result = Index(dti, dtype="category") expected = CategoricalIndex(dti) tm.assert_index_equal(result, expected) dti2 = date_range("2016-01-01", periods=3, tz="US/Pacific") result = Index(dti2, dtype="category") expected = CategoricalIndex(dti2) tm.assert_index_equal(result, expected) def test_constructor_period_values_mismatched_dtype(self): pi = period_range("2016-01-01", periods=3, freq="D") result = Index(pi, dtype="category") expected = CategoricalIndex(pi) tm.assert_index_equal(result, expected) def test_constructor_timedelta64_values_mismatched_dtype(self): # check we don't silently ignore the dtype keyword tdi = timedelta_range("4 Days", periods=5) result = Index(tdi, dtype="category") expected = CategoricalIndex(tdi) tm.assert_index_equal(result, expected) def test_constructor_interval_values_mismatched_dtype(self): dti = date_range("2016-01-01", periods=3) ii = IntervalIndex.from_breaks(dti) result = Index(ii, dtype="category") expected = CategoricalIndex(ii) tm.assert_index_equal(result, expected) def test_constructor_datetime64_values_mismatched_period_dtype(self): dti = date_range("2016-01-01", periods=3) result = Index(dti, dtype="Period[D]") expected = dti.to_period("D") tm.assert_index_equal(result, expected) @pytest.mark.parametrize("dtype", ["int64", "uint64"]) def test_constructor_int_dtype_nan_raises(self, dtype): # see GH#15187 data = [np.nan] msg = "cannot convert" with pytest.raises(ValueError, match=msg): Index(data, dtype=dtype) @pytest.mark.parametrize( "vals", [ [1, 2, 3], np.array([1, 2, 3]), np.array([1, 2, 3], dtype=int), # below should coerce [1.0, 2.0, 3.0], np.array([1.0, 2.0, 3.0], dtype=float), ], ) def test_constructor_dtypes_to_int64(self, vals): index = Index(vals, dtype=int) assert isinstance(index, Int64Index) @pytest.mark.parametrize( "vals", [ [1, 2, 3], [1.0, 2.0, 3.0], np.array([1.0, 2.0, 3.0]), np.array([1, 2, 3], dtype=int), np.array([1.0, 2.0, 3.0], dtype=float), ], ) def test_constructor_dtypes_to_float64(self, vals): index = Index(vals, dtype=float) assert isinstance(index, Float64Index) @pytest.mark.parametrize( "vals", [ [1, 2, 3], np.array([1, 2, 3], dtype=int), np.array([ np_datetime64_compat("2011-01-01"), np_datetime64_compat("2011-01-02") ]), [datetime(2011, 1, 1), datetime(2011, 1, 2)], ], ) def test_constructor_dtypes_to_categorical(self, vals): index = Index(vals, dtype="category") assert isinstance(index, CategoricalIndex) @pytest.mark.parametrize("cast_index", [True, False]) @pytest.mark.parametrize( "vals", [ Index( np.array([ np_datetime64_compat("2011-01-01"), np_datetime64_compat("2011-01-02"), ])), Index([datetime(2011, 1, 1), datetime(2011, 1, 2)]), ], ) def test_constructor_dtypes_to_datetime(self, cast_index, vals): if cast_index: index = Index(vals, dtype=object) assert isinstance(index, Index) assert index.dtype == object else: index = Index(vals) assert isinstance(index, DatetimeIndex) @pytest.mark.parametrize("cast_index", [True, False]) @pytest.mark.parametrize( "vals", [ np.array([np.timedelta64(1, "D"), np.timedelta64(1, "D")]), [timedelta(1), timedelta(1)], ], ) def test_constructor_dtypes_to_timedelta(self, cast_index, vals): if cast_index: index = Index(vals, dtype=object) assert isinstance(index, Index) assert index.dtype == object else: index = Index(vals) assert isinstance(index, TimedeltaIndex)