From 01af5af91233235ef812e484a651a3fce652f4f2 Mon Sep 17 00:00:00 2001 From: Matthew Roeschke <10647082+mroeschke@users.noreply.github.com> Date: Thu, 13 Oct 2022 21:31:25 -0700 Subject: [PATCH 1/3] Remove need for self.d --- pandas/tests/tseries/offsets/common.py | 4 - pandas/tests/tseries/offsets/conftest.py | 11 ++ .../tseries/offsets/test_business_day.py | 35 ++--- .../tseries/offsets/test_business_hour.py | 125 +++++++++--------- .../offsets/test_custom_business_day.py | 29 ++-- .../offsets/test_custom_business_hour.py | 30 +++-- .../offsets/test_custom_business_month.py | 33 ++--- pandas/tests/tseries/offsets/test_offsets.py | 50 +++---- 8 files changed, 167 insertions(+), 150 deletions(-) diff --git a/pandas/tests/tseries/offsets/common.py b/pandas/tests/tseries/offsets/common.py index 50b6907a02eaf..cefd4b6d597c4 100644 --- a/pandas/tests/tseries/offsets/common.py +++ b/pandas/tests/tseries/offsets/common.py @@ -3,9 +3,6 @@ """ from __future__ import annotations -from datetime import datetime - -from pandas._libs.tslibs import Timestamp from pandas._libs.tslibs.offsets import ( FY5253, BaseOffset, @@ -52,7 +49,6 @@ class WeekDay: class Base: _offset: type[BaseOffset] | None = None - d = Timestamp(datetime(2008, 1, 2)) def _get_offset(self, klass, value=1, normalize=False): # create instance from offset class diff --git a/pandas/tests/tseries/offsets/conftest.py b/pandas/tests/tseries/offsets/conftest.py index 72f5c4a519a3a..ee6da4a9789fe 100644 --- a/pandas/tests/tseries/offsets/conftest.py +++ b/pandas/tests/tseries/offsets/conftest.py @@ -1,5 +1,8 @@ +import datetime + import pytest +from pandas._libs.tslibs import Timestamp from pandas._libs.tslibs.offsets import MonthOffset import pandas.tseries.offsets as offsets @@ -29,3 +32,11 @@ def month_classes(request): Fixture for month based datetime offsets available for a time series. """ return request.param + + +@pytest.fixture +def d(): + """ + Fixture for common Timestamp. + """ + return Timestamp(datetime.datetime(2008, 1, 2)) diff --git a/pandas/tests/tseries/offsets/test_business_day.py b/pandas/tests/tseries/offsets/test_business_day.py index f23772dd0bd7c..4338a6c3e1d02 100644 --- a/pandas/tests/tseries/offsets/test_business_day.py +++ b/pandas/tests/tseries/offsets/test_business_day.py @@ -32,13 +32,15 @@ from pandas.tseries import offsets as offsets +@pytest.fixture +def d(): + return datetime(2008, 1, 1) + + class TestBusinessDay(Base): _offset: type[BDay] = BDay def setup_method(self): - self.d = datetime(2008, 1, 1) - self.nd = np.datetime64("2008-01-01 00:00:00") - self.offset = self._offset() self.offset1 = self.offset self.offset2 = self._offset(2) @@ -56,10 +58,10 @@ def test_repr(self): expected = "" assert repr(self.offset + timedelta(1)) == expected - def test_with_offset(self): + def test_with_offset(self, d): offset = self.offset + timedelta(hours=2) - assert (self.d + offset) == datetime(2008, 1, 2, 2) + assert (d + offset) == datetime(2008, 1, 2, 2) @pytest.mark.parametrize( "td", @@ -70,9 +72,9 @@ def test_with_offset(self): ], ids=lambda x: type(x), ) - def test_with_offset_index(self, td): + def test_with_offset_index(self, td, d): - dti = DatetimeIndex([self.d]) + dti = DatetimeIndex([d]) expected = DatetimeIndex([datetime(2008, 1, 2, 2)]) result = dti + (td + self.offset) @@ -84,26 +86,25 @@ def test_with_offset_index(self, td): def test_eq(self): assert self.offset2 == self.offset2 - def test_mul(self): - pass - def test_hash(self): assert hash(self.offset2) == hash(self.offset2) - def test_call(self): + def test_call(self, d): with tm.assert_produces_warning(FutureWarning): # GH#34171 DateOffset.__call__ is deprecated - assert self.offset2(self.d) == datetime(2008, 1, 3) - assert self.offset2(self.nd) == datetime(2008, 1, 3) + assert self.offset2(d) == datetime(2008, 1, 3) + assert self.offset2(np.datetime64("2008-01-01 00:00:00")) == datetime( + 2008, 1, 3 + ) - def testRollback1(self): - assert self._offset(10).rollback(self.d) == self.d + def testRollback1(self, d): + assert self._offset(10).rollback(d) == d def testRollback2(self): assert self._offset(10).rollback(datetime(2008, 1, 5)) == datetime(2008, 1, 4) - def testRollforward1(self): - assert self._offset(10).rollforward(self.d) == self.d + def testRollforward1(self, d): + assert self._offset(10).rollforward(d) == d def testRollforward2(self): assert self._offset(10).rollforward(datetime(2008, 1, 5)) == datetime( diff --git a/pandas/tests/tseries/offsets/test_business_hour.py b/pandas/tests/tseries/offsets/test_business_hour.py index 392991009a449..91f24ece50e24 100644 --- a/pandas/tests/tseries/offsets/test_business_hour.py +++ b/pandas/tests/tseries/offsets/test_business_hour.py @@ -31,12 +31,15 @@ ) +@pytest.fixture +def d(): + return datetime(2014, 7, 1, 10, 00) + + class TestBusinessHour(Base): _offset: type[BusinessHour] = BusinessHour def setup_method(self): - self.d = datetime(2014, 7, 1, 10, 00) - self.offset1 = BusinessHour() self.offset2 = BusinessHour(n=3) @@ -115,11 +118,11 @@ def test_repr(self): assert repr(self.offset9) == "<3 * BusinessHours: BH=09:00-13:00,22:00-03:00>" assert repr(self.offset10) == "<-1 * BusinessHour: BH=13:00-17:00,23:00-02:00>" - def test_with_offset(self): + def test_with_offset(self, d): expected = Timestamp("2014-07-01 13:00") - assert self.d + BusinessHour() * 3 == expected - assert self.d + BusinessHour(n=3) == expected + assert d + BusinessHour() * 3 == expected + assert d + BusinessHour(n=3) == expected @pytest.mark.parametrize( "offset_name", @@ -168,84 +171,84 @@ def test_hash(self, offset_name): offset = getattr(self, offset_name) assert offset == offset - def test_call(self): + def test_call(self, d): with tm.assert_produces_warning(FutureWarning): # GH#34171 DateOffset.__call__ is deprecated - assert self.offset1(self.d) == datetime(2014, 7, 1, 11) - assert self.offset2(self.d) == datetime(2014, 7, 1, 13) - assert self.offset3(self.d) == datetime(2014, 6, 30, 17) - assert self.offset4(self.d) == datetime(2014, 6, 30, 14) - assert self.offset8(self.d) == datetime(2014, 7, 1, 11) - assert self.offset9(self.d) == datetime(2014, 7, 1, 22) - assert self.offset10(self.d) == datetime(2014, 7, 1, 1) + assert self.offset1(d) == datetime(2014, 7, 1, 11) + assert self.offset2(d) == datetime(2014, 7, 1, 13) + assert self.offset3(d) == datetime(2014, 6, 30, 17) + assert self.offset4(d) == datetime(2014, 6, 30, 14) + assert self.offset8(d) == datetime(2014, 7, 1, 11) + assert self.offset9(d) == datetime(2014, 7, 1, 22) + assert self.offset10(d) == datetime(2014, 7, 1, 1) - def test_sub(self): + def test_sub(self, d): # we have to override test_sub here because self.offset2 is not # defined as self._offset(2) off = self.offset2 msg = "Cannot subtract datetime from offset" with pytest.raises(TypeError, match=msg): - off - self.d + off - d assert 2 * off - off == off - assert self.d - self.offset2 == self.d + self._offset(-3) - - def testRollback1(self): - assert self.offset1.rollback(self.d) == self.d - assert self.offset2.rollback(self.d) == self.d - assert self.offset3.rollback(self.d) == self.d - assert self.offset4.rollback(self.d) == self.d - assert self.offset5.rollback(self.d) == datetime(2014, 6, 30, 14, 30) - assert self.offset6.rollback(self.d) == datetime(2014, 7, 1, 5, 0) - assert self.offset7.rollback(self.d) == datetime(2014, 7, 1, 6, 30) - assert self.offset8.rollback(self.d) == self.d - assert self.offset9.rollback(self.d) == self.d - assert self.offset10.rollback(self.d) == datetime(2014, 7, 1, 2) + assert d - self.offset2 == d + self._offset(-3) - d = datetime(2014, 7, 1, 0) - assert self.offset1.rollback(d) == datetime(2014, 6, 30, 17) - assert self.offset2.rollback(d) == datetime(2014, 6, 30, 17) - assert self.offset3.rollback(d) == datetime(2014, 6, 30, 17) - assert self.offset4.rollback(d) == datetime(2014, 6, 30, 17) + def testRollback1(self, d): + assert self.offset1.rollback(d) == d + assert self.offset2.rollback(d) == d + assert self.offset3.rollback(d) == d + assert self.offset4.rollback(d) == d assert self.offset5.rollback(d) == datetime(2014, 6, 30, 14, 30) - assert self.offset6.rollback(d) == d - assert self.offset7.rollback(d) == d - assert self.offset8.rollback(d) == datetime(2014, 6, 30, 17) + assert self.offset6.rollback(d) == datetime(2014, 7, 1, 5, 0) + assert self.offset7.rollback(d) == datetime(2014, 7, 1, 6, 30) + assert self.offset8.rollback(d) == d assert self.offset9.rollback(d) == d - assert self.offset10.rollback(d) == d + assert self.offset10.rollback(d) == datetime(2014, 7, 1, 2) - assert self._offset(5).rollback(self.d) == self.d + datet = datetime(2014, 7, 1, 0) + assert self.offset1.rollback(datet) == datetime(2014, 6, 30, 17) + assert self.offset2.rollback(datet) == datetime(2014, 6, 30, 17) + assert self.offset3.rollback(datet) == datetime(2014, 6, 30, 17) + assert self.offset4.rollback(datet) == datetime(2014, 6, 30, 17) + assert self.offset5.rollback(datet) == datetime(2014, 6, 30, 14, 30) + assert self.offset6.rollback(datet) == datet + assert self.offset7.rollback(datet) == datet + assert self.offset8.rollback(datet) == datetime(2014, 6, 30, 17) + assert self.offset9.rollback(datet) == datet + assert self.offset10.rollback(datet) == datet + + assert self._offset(5).rollback(d) == d def testRollback2(self): assert self._offset(-3).rollback(datetime(2014, 7, 5, 15, 0)) == datetime( 2014, 7, 4, 17, 0 ) - def testRollforward1(self): - assert self.offset1.rollforward(self.d) == self.d - assert self.offset2.rollforward(self.d) == self.d - assert self.offset3.rollforward(self.d) == self.d - assert self.offset4.rollforward(self.d) == self.d - assert self.offset5.rollforward(self.d) == datetime(2014, 7, 1, 11, 0) - assert self.offset6.rollforward(self.d) == datetime(2014, 7, 1, 20, 0) - assert self.offset7.rollforward(self.d) == datetime(2014, 7, 1, 21, 30) - assert self.offset8.rollforward(self.d) == self.d - assert self.offset9.rollforward(self.d) == self.d - assert self.offset10.rollforward(self.d) == datetime(2014, 7, 1, 13) - - d = datetime(2014, 7, 1, 0) - assert self.offset1.rollforward(d) == datetime(2014, 7, 1, 9) - assert self.offset2.rollforward(d) == datetime(2014, 7, 1, 9) - assert self.offset3.rollforward(d) == datetime(2014, 7, 1, 9) - assert self.offset4.rollforward(d) == datetime(2014, 7, 1, 9) - assert self.offset5.rollforward(d) == datetime(2014, 7, 1, 11) - assert self.offset6.rollforward(d) == d - assert self.offset7.rollforward(d) == d - assert self.offset8.rollforward(d) == datetime(2014, 7, 1, 9) + def testRollforward1(self, d): + assert self.offset1.rollforward(d) == d + assert self.offset2.rollforward(d) == d + assert self.offset3.rollforward(d) == d + assert self.offset4.rollforward(d) == d + assert self.offset5.rollforward(d) == datetime(2014, 7, 1, 11, 0) + assert self.offset6.rollforward(d) == datetime(2014, 7, 1, 20, 0) + assert self.offset7.rollforward(d) == datetime(2014, 7, 1, 21, 30) + assert self.offset8.rollforward(d) == d assert self.offset9.rollforward(d) == d - assert self.offset10.rollforward(d) == d + assert self.offset10.rollforward(d) == datetime(2014, 7, 1, 13) + + datet = datetime(2014, 7, 1, 0) + assert self.offset1.rollforward(datet) == datetime(2014, 7, 1, 9) + assert self.offset2.rollforward(datet) == datetime(2014, 7, 1, 9) + assert self.offset3.rollforward(datet) == datetime(2014, 7, 1, 9) + assert self.offset4.rollforward(datet) == datetime(2014, 7, 1, 9) + assert self.offset5.rollforward(datet) == datetime(2014, 7, 1, 11) + assert self.offset6.rollforward(datet) == datet + assert self.offset7.rollforward(datet) == datet + assert self.offset8.rollforward(datet) == datetime(2014, 7, 1, 9) + assert self.offset9.rollforward(datet) == datet + assert self.offset10.rollforward(datet) == datet - assert self._offset(5).rollforward(self.d) == self.d + assert self._offset(5).rollforward(d) == d def testRollforward2(self): assert self._offset(-3).rollforward(datetime(2014, 7, 5, 16, 0)) == datetime( diff --git a/pandas/tests/tseries/offsets/test_custom_business_day.py b/pandas/tests/tseries/offsets/test_custom_business_day.py index 3bbbaa891709f..1d6a39fbfa3e3 100644 --- a/pandas/tests/tseries/offsets/test_custom_business_day.py +++ b/pandas/tests/tseries/offsets/test_custom_business_day.py @@ -16,20 +16,29 @@ read_pickle, ) from pandas.tests.tseries.offsets.common import assert_offset_equal -from pandas.tests.tseries.offsets.test_business_day import TestBusinessDay from pandas.tseries.holiday import USFederalHolidayCalendar -class TestCustomBusinessDay(TestBusinessDay): +@pytest.fixture +def offset(): + return CDay() + + +@pytest.fixture +def offset2(): + return CDay(2) + + +class TestCustomBusinessDay: _offset = CDay - def test_repr(self): - assert repr(self.offset) == "" - assert repr(self.offset2) == "<2 * CustomBusinessDays>" + def test_repr(self, offset, offset2): + assert repr(offset) == "" + assert repr(offset2) == "<2 * CustomBusinessDays>" expected = "" - assert repr(self.offset + timedelta(1)) == expected + assert repr(offset + timedelta(1)) == expected def test_holidays(self): # Define a TradingDay offset @@ -74,14 +83,14 @@ def test_calendar(self): dt = datetime(2014, 1, 17) assert_offset_equal(CDay(calendar=calendar), dt, datetime(2014, 1, 21)) - def test_roundtrip_pickle(self): + def test_roundtrip_pickle(self, offset, offset2): def _check_roundtrip(obj): unpickled = tm.round_trip_pickle(obj) assert unpickled == obj - _check_roundtrip(self.offset) - _check_roundtrip(self.offset2) - _check_roundtrip(self.offset * 2) + _check_roundtrip(offset) + _check_roundtrip(offset2) + _check_roundtrip(offset * 2) def test_pickle_compat_0_14_1(self, datapath): hdays = [datetime(2013, 1, 1) for ele in range(4)] diff --git a/pandas/tests/tseries/offsets/test_custom_business_hour.py b/pandas/tests/tseries/offsets/test_custom_business_hour.py index 360b541ce7c90..29ffd9dca6b34 100644 --- a/pandas/tests/tseries/offsets/test_custom_business_hour.py +++ b/pandas/tests/tseries/offsets/test_custom_business_hour.py @@ -24,6 +24,11 @@ from pandas.tseries.holiday import USFederalHolidayCalendar +@pytest.fixture +def d(): + return datetime(2014, 7, 1, 10, 00) + + class TestCustomBusinessHour(Base): _offset: type[CustomBusinessHour] = CustomBusinessHour holidays = ["2014-06-27", datetime(2014, 6, 30), np.datetime64("2014-07-02")] @@ -34,7 +39,6 @@ def setup_method(self): # 6/22 23 24 25 26 27 28 # 29 30 7/1 2 3 4 5 # 6 7 8 9 10 11 12 - self.d = datetime(2014, 7, 1, 10, 00) self.offset1 = CustomBusinessHour(weekmask="Tue Wed Thu Fri") self.offset2 = CustomBusinessHour(holidays=self.holidays) @@ -62,11 +66,11 @@ def test_repr(self): assert repr(self.offset1) == "" assert repr(self.offset2) == "" - def test_with_offset(self): + def test_with_offset(self, d): expected = Timestamp("2014-07-01 13:00") - assert self.d + CustomBusinessHour() * 3 == expected - assert self.d + CustomBusinessHour(n=3) == expected + assert d + CustomBusinessHour() * 3 == expected + assert d + CustomBusinessHour(n=3) == expected def test_eq(self): for offset in [self.offset1, self.offset2]: @@ -90,15 +94,15 @@ def test_hash(self): assert hash(self.offset1) == hash(self.offset1) assert hash(self.offset2) == hash(self.offset2) - def test_call(self): + def test_call(self, d): with tm.assert_produces_warning(FutureWarning): # GH#34171 DateOffset.__call__ is deprecated - assert self.offset1(self.d) == datetime(2014, 7, 1, 11) - assert self.offset2(self.d) == datetime(2014, 7, 1, 11) + assert self.offset1(d) == datetime(2014, 7, 1, 11) + assert self.offset2(d) == datetime(2014, 7, 1, 11) - def testRollback1(self): - assert self.offset1.rollback(self.d) == self.d - assert self.offset2.rollback(self.d) == self.d + def testRollback1(self, d): + assert self.offset1.rollback(d) == d + assert self.offset2.rollback(d) == d d = datetime(2014, 7, 1, 0) @@ -113,9 +117,9 @@ def testRollback2(self): 2014, 7, 4, 17, 0 ) - def testRollforward1(self): - assert self.offset1.rollforward(self.d) == self.d - assert self.offset2.rollforward(self.d) == self.d + def testRollforward1(self, d): + assert self.offset1.rollforward(d) == d + assert self.offset2.rollforward(d) == d d = datetime(2014, 7, 1, 0) assert self.offset1.rollforward(d) == datetime(2014, 7, 1, 9) diff --git a/pandas/tests/tseries/offsets/test_custom_business_month.py b/pandas/tests/tseries/offsets/test_custom_business_month.py index c0f9b3cb5be87..460d1e20b63ca 100644 --- a/pandas/tests/tseries/offsets/test_custom_business_month.py +++ b/pandas/tests/tseries/offsets/test_custom_business_month.py @@ -37,9 +37,13 @@ from pandas.tseries.holiday import USFederalHolidayCalendar +@pytest.fixture +def d(): + return datetime(2008, 1, 1) + + class CustomBusinessMonthBase: def setup_method(self): - self.d = datetime(2008, 1, 1) self.offset = self._offset() self.offset1 = self.offset self.offset2 = self._offset(2) @@ -47,9 +51,6 @@ def setup_method(self): def test_eq(self): assert self.offset2 == self.offset2 - def test_mul(self): - pass - def test_hash(self): assert hash(self.offset2) == hash(self.offset2) @@ -81,19 +82,19 @@ def test_repr(self): assert repr(self.offset) == "" assert repr(self.offset2) == "<2 * CustomBusinessMonthBegins>" - def test_call(self): + def test_call(self, d): with tm.assert_produces_warning(FutureWarning): # GH#34171 DateOffset.__call__ is deprecated - assert self.offset2(self.d) == datetime(2008, 3, 3) + assert self.offset2(d) == datetime(2008, 3, 3) def testRollback1(self): assert CDay(10).rollback(datetime(2007, 12, 31)) == datetime(2007, 12, 31) - def testRollback2(self): - assert CBMonthBegin(10).rollback(self.d) == datetime(2008, 1, 1) + def testRollback2(self, d): + assert CBMonthBegin(10).rollback(d) == datetime(2008, 1, 1) - def testRollforward1(self): - assert CBMonthBegin(10).rollforward(self.d) == datetime(2008, 1, 1) + def testRollforward1(self, d): + assert CBMonthBegin(10).rollforward(d) == datetime(2008, 1, 1) def test_roll_date_object(self): offset = CBMonthBegin() @@ -271,19 +272,19 @@ def test_repr(self): assert repr(self.offset) == "" assert repr(self.offset2) == "<2 * CustomBusinessMonthEnds>" - def test_call(self): + def test_call(self, d): with tm.assert_produces_warning(FutureWarning): # GH#34171 DateOffset.__call__ is deprecated - assert self.offset2(self.d) == datetime(2008, 2, 29) + assert self.offset2(d) == datetime(2008, 2, 29) def testRollback1(self): assert CDay(10).rollback(datetime(2007, 12, 31)) == datetime(2007, 12, 31) - def testRollback2(self): - assert CBMonthEnd(10).rollback(self.d) == datetime(2007, 12, 31) + def testRollback2(self, d): + assert CBMonthEnd(10).rollback(d) == datetime(2007, 12, 31) - def testRollforward1(self): - assert CBMonthEnd(10).rollforward(self.d) == datetime(2008, 1, 31) + def testRollforward1(self, d): + assert CBMonthEnd(10).rollforward(d) == datetime(2008, 1, 31) def test_roll_date_object(self): offset = CBMonthEnd() diff --git a/pandas/tests/tseries/offsets/test_offsets.py b/pandas/tests/tseries/offsets/test_offsets.py index 34266e55d9ea9..14e65bba17a7d 100644 --- a/pandas/tests/tseries/offsets/test_offsets.py +++ b/pandas/tests/tseries/offsets/test_offsets.py @@ -80,6 +80,11 @@ ] +@pytest.fixture +def d(): + return Timestamp(datetime(2008, 1, 2)) + + class TestCommon(Base): # executed value created by Base._get_offset # are applied to 2011/01/01 09:00 (Saturday) @@ -595,7 +600,6 @@ def test_add_dt64_ndarray_non_nano(self, offset_types, unit, request): class TestDateOffset(Base): def setup_method(self): - self.d = Timestamp(datetime(2008, 1, 2)) _offset_map.clear() def test_repr(self): @@ -622,8 +626,8 @@ def test_constructor(self, kwd, request): assert offset.kwds == {kwd: 2} assert getattr(offset, kwd) == 2 - def test_default_constructor(self): - assert (self.d + DateOffset(2)) == datetime(2008, 1, 4) + def test_default_constructor(self, d): + assert (d + DateOffset(2)) == datetime(2008, 1, 4) def test_is_anchored(self): assert not DateOffset(2).is_anchored() @@ -650,9 +654,9 @@ def test_copy(self): ], ), ) - def test_add(self, arithmatic_offset_type, expected): - assert DateOffset(**{arithmatic_offset_type: 1}) + self.d == Timestamp(expected) - assert self.d + DateOffset(**{arithmatic_offset_type: 1}) == Timestamp(expected) + def test_add(self, arithmatic_offset_type, expected, d): + assert DateOffset(**{arithmatic_offset_type: 1}) + d == Timestamp(expected) + assert d + DateOffset(**{arithmatic_offset_type: 1}) == Timestamp(expected) @pytest.mark.parametrize( "arithmatic_offset_type, expected", @@ -671,10 +675,10 @@ def test_add(self, arithmatic_offset_type, expected): ], ), ) - def test_sub(self, arithmatic_offset_type, expected): - assert self.d - DateOffset(**{arithmatic_offset_type: 1}) == Timestamp(expected) + def test_sub(self, arithmatic_offset_type, expected, d): + assert d - DateOffset(**{arithmatic_offset_type: 1}) == Timestamp(expected) with pytest.raises(TypeError, match="Cannot subtract datetime from offset"): - DateOffset(**{arithmatic_offset_type: 1}) - self.d + DateOffset(**{arithmatic_offset_type: 1}) - d @pytest.mark.parametrize( "arithmatic_offset_type, n, expected", @@ -694,19 +698,11 @@ def test_sub(self, arithmatic_offset_type, expected): ], ), ) - def test_mul_add(self, arithmatic_offset_type, n, expected): - assert DateOffset(**{arithmatic_offset_type: 1}) * n + self.d == Timestamp( - expected - ) - assert n * DateOffset(**{arithmatic_offset_type: 1}) + self.d == Timestamp( - expected - ) - assert self.d + DateOffset(**{arithmatic_offset_type: 1}) * n == Timestamp( - expected - ) - assert self.d + n * DateOffset(**{arithmatic_offset_type: 1}) == Timestamp( - expected - ) + def test_mul_add(self, arithmatic_offset_type, n, expected, d): + assert DateOffset(**{arithmatic_offset_type: 1}) * n + d == Timestamp(expected) + assert n * DateOffset(**{arithmatic_offset_type: 1}) + d == Timestamp(expected) + assert d + DateOffset(**{arithmatic_offset_type: 1}) * n == Timestamp(expected) + assert d + n * DateOffset(**{arithmatic_offset_type: 1}) == Timestamp(expected) @pytest.mark.parametrize( "arithmatic_offset_type, n, expected", @@ -726,13 +722,9 @@ def test_mul_add(self, arithmatic_offset_type, n, expected): ], ), ) - def test_mul_sub(self, arithmatic_offset_type, n, expected): - assert self.d - DateOffset(**{arithmatic_offset_type: 1}) * n == Timestamp( - expected - ) - assert self.d - n * DateOffset(**{arithmatic_offset_type: 1}) == Timestamp( - expected - ) + def test_mul_sub(self, arithmatic_offset_type, n, expected, d): + assert d - DateOffset(**{arithmatic_offset_type: 1}) * n == Timestamp(expected) + assert d - n * DateOffset(**{arithmatic_offset_type: 1}) == Timestamp(expected) def test_leap_year(self): d = datetime(2008, 1, 31) From a3db7756ff32f05ac8a6ee17b9521ec6c4ac0e15 Mon Sep 17 00:00:00 2001 From: Matthew Roeschke <10647082+mroeschke@users.noreply.github.com> Date: Thu, 13 Oct 2022 22:45:52 -0700 Subject: [PATCH 2/3] Remove Base --- pandas/tests/tseries/offsets/common.py | 45 --- .../tseries/offsets/test_business_day.py | 120 +++---- .../tseries/offsets/test_business_hour.py | 293 +++++++++++------- .../tseries/offsets/test_business_month.py | 11 +- .../tseries/offsets/test_business_quarter.py | 11 +- .../tseries/offsets/test_business_year.py | 15 +- .../offsets/test_custom_business_day.py | 2 - .../offsets/test_custom_business_hour.py | 131 ++++---- .../offsets/test_custom_business_month.py | 93 +++--- pandas/tests/tseries/offsets/test_easter.py | 7 +- pandas/tests/tseries/offsets/test_fiscal.py | 9 +- pandas/tests/tseries/offsets/test_month.py | 22 +- pandas/tests/tseries/offsets/test_offsets.py | 98 ++++-- pandas/tests/tseries/offsets/test_quarter.py | 34 +- pandas/tests/tseries/offsets/test_week.py | 21 +- pandas/tests/tseries/offsets/test_year.py | 13 +- 16 files changed, 473 insertions(+), 452 deletions(-) diff --git a/pandas/tests/tseries/offsets/common.py b/pandas/tests/tseries/offsets/common.py index cefd4b6d597c4..efb010addad22 100644 --- a/pandas/tests/tseries/offsets/common.py +++ b/pandas/tests/tseries/offsets/common.py @@ -3,16 +3,6 @@ """ from __future__ import annotations -from pandas._libs.tslibs.offsets import ( - FY5253, - BaseOffset, - DateOffset, - FY5253Quarter, - LastWeekOfMonth, - Week, - WeekOfMonth, -) - def assert_offset_equal(offset, base, expected): actual = offset + base @@ -45,38 +35,3 @@ class WeekDay: FRI = 4 SAT = 5 SUN = 6 - - -class Base: - _offset: type[BaseOffset] | None = None - - def _get_offset(self, klass, value=1, normalize=False): - # create instance from offset class - if klass is FY5253: - klass = klass( - n=value, - startingMonth=1, - weekday=1, - variation="last", - normalize=normalize, - ) - elif klass is FY5253Quarter: - klass = klass( - n=value, - startingMonth=1, - weekday=1, - qtr_with_extra_week=1, - variation="last", - normalize=normalize, - ) - elif klass is LastWeekOfMonth: - klass = klass(n=value, weekday=5, normalize=normalize) - elif klass is WeekOfMonth: - klass = klass(n=value, week=1, weekday=5, normalize=normalize) - elif klass is Week: - klass = klass(n=value, weekday=5, normalize=normalize) - elif klass is DateOffset: - klass = klass(days=value, normalize=normalize) - else: - klass = klass(value, normalize=normalize) - return klass diff --git a/pandas/tests/tseries/offsets/test_business_day.py b/pandas/tests/tseries/offsets/test_business_day.py index 4338a6c3e1d02..448f35d8ec525 100644 --- a/pandas/tests/tseries/offsets/test_business_day.py +++ b/pandas/tests/tseries/offsets/test_business_day.py @@ -24,7 +24,6 @@ _testing as tm, ) from pandas.tests.tseries.offsets.common import ( - Base, assert_is_on_offset, assert_offset_equal, ) @@ -37,29 +36,37 @@ def d(): return datetime(2008, 1, 1) -class TestBusinessDay(Base): - _offset: type[BDay] = BDay +@pytest.fixture +def _offset(): + return BDay + + +@pytest.fixture +def offset(_offset): + return _offset() + + +@pytest.fixture +def offset2(_offset): + return _offset(2) - def setup_method(self): - self.offset = self._offset() - self.offset1 = self.offset - self.offset2 = self._offset(2) - def test_different_normalize_equals(self): +class TestBusinessDay: + def test_different_normalize_equals(self, _offset, offset2): # GH#21404 changed __eq__ to return False when `normalize` does not match - offset = self._offset() - offset2 = self._offset(normalize=True) + offset = _offset() + offset2 = _offset(normalize=True) assert offset != offset2 - def test_repr(self): - assert repr(self.offset) == "" - assert repr(self.offset2) == "<2 * BusinessDays>" + def test_repr(self, offset, offset2): + assert repr(offset) == "" + assert repr(offset2) == "<2 * BusinessDays>" expected = "" - assert repr(self.offset + timedelta(1)) == expected + assert repr(offset + timedelta(1)) == expected - def test_with_offset(self, d): - offset = self.offset + timedelta(hours=2) + def test_with_offset(self, d, offset): + offset = offset + timedelta(hours=2) assert (d + offset) == datetime(2008, 1, 2, 2) @@ -72,48 +79,42 @@ def test_with_offset(self, d): ], ids=lambda x: type(x), ) - def test_with_offset_index(self, td, d): + def test_with_offset_index(self, td, d, offset): dti = DatetimeIndex([d]) expected = DatetimeIndex([datetime(2008, 1, 2, 2)]) - result = dti + (td + self.offset) + result = dti + (td + offset) tm.assert_index_equal(result, expected) - result = dti + (self.offset + td) + result = dti + (offset + td) tm.assert_index_equal(result, expected) - def test_eq(self): - assert self.offset2 == self.offset2 + def test_eq(self, offset2): + assert offset2 == offset2 - def test_hash(self): - assert hash(self.offset2) == hash(self.offset2) + def test_hash(self, offset2): + assert hash(offset2) == hash(offset2) - def test_call(self, d): + def test_call(self, d, offset2): with tm.assert_produces_warning(FutureWarning): # GH#34171 DateOffset.__call__ is deprecated - assert self.offset2(d) == datetime(2008, 1, 3) - assert self.offset2(np.datetime64("2008-01-01 00:00:00")) == datetime( - 2008, 1, 3 - ) - - def testRollback1(self, d): - assert self._offset(10).rollback(d) == d + assert offset2(d) == datetime(2008, 1, 3) + assert offset2(np.datetime64("2008-01-01 00:00:00")) == datetime(2008, 1, 3) - def testRollback2(self): - assert self._offset(10).rollback(datetime(2008, 1, 5)) == datetime(2008, 1, 4) + def testRollback1(self, d, _offset): + assert _offset(10).rollback(d) == d - def testRollforward1(self, d): - assert self._offset(10).rollforward(d) == d + def testRollback2(self, _offset): + assert _offset(10).rollback(datetime(2008, 1, 5)) == datetime(2008, 1, 4) - def testRollforward2(self): - assert self._offset(10).rollforward(datetime(2008, 1, 5)) == datetime( - 2008, 1, 7 - ) + def testRollforward1(self, d, _offset): + assert _offset(10).rollforward(d) == d - def test_roll_date_object(self): - offset = self._offset() + def testRollforward2(self, _offset): + assert _offset(10).rollforward(datetime(2008, 1, 5)) == datetime(2008, 1, 7) + def test_roll_date_object(self, offset): dt = date(2012, 9, 15) result = offset.rollback(dt) @@ -129,14 +130,15 @@ def test_roll_date_object(self): result = offset.rollforward(dt) assert result == datetime(2012, 9, 15) - def test_is_on_offset(self): - tests = [ - (self._offset(), datetime(2008, 1, 1), True), - (self._offset(), datetime(2008, 1, 5), False), - ] - - for offset, d, expected in tests: - assert_is_on_offset(offset, d, expected) + @pytest.mark.parametrize( + "dt, expected", + [ + (datetime(2008, 1, 1), True), + (datetime(2008, 1, 5), False), + ], + ) + def test_is_on_offset(self, offset, dt, expected): + assert_is_on_offset(offset, dt, expected) apply_cases: list[tuple[int, dict[datetime, datetime]]] = [ ( @@ -195,22 +197,22 @@ def test_is_on_offset(self): ] @pytest.mark.parametrize("case", apply_cases) - def test_apply(self, case): + def test_apply(self, case, _offset): n, cases = case - offset = self._offset(n) + offset = _offset(n) for base, expected in cases.items(): assert_offset_equal(offset, base, expected) - def test_apply_large_n(self): + def test_apply_large_n(self, _offset): dt = datetime(2012, 10, 23) - result = dt + self._offset(10) + result = dt + _offset(10) assert result == datetime(2012, 11, 6) - result = dt + self._offset(100) - self._offset(100) + result = dt + _offset(100) - _offset(100) assert result == dt - off = self._offset() * 6 + off = _offset() * 6 rs = datetime(2012, 1, 1) - off xp = datetime(2011, 12, 23) assert rs == xp @@ -220,13 +222,13 @@ def test_apply_large_n(self): xp = datetime(2011, 12, 26) assert rs == xp - off = self._offset() * 10 + off = _offset() * 10 rs = datetime(2014, 1, 5) + off # see #5890 xp = datetime(2014, 1, 17) assert rs == xp - def test_apply_corner(self): - if self._offset is BDay: + def test_apply_corner(self, _offset): + if _offset is BDay: msg = "Only know how to combine business day with datetime or timedelta" else: msg = ( @@ -234,4 +236,4 @@ def test_apply_corner(self): "with datetime, datetime64 or timedelta" ) with pytest.raises(ApplyTypeError, match=msg): - self._offset()._apply(BMonthEnd()) + _offset()._apply(BMonthEnd()) diff --git a/pandas/tests/tseries/offsets/test_business_hour.py b/pandas/tests/tseries/offsets/test_business_hour.py index 91f24ece50e24..381d538fca5c0 100644 --- a/pandas/tests/tseries/offsets/test_business_hour.py +++ b/pandas/tests/tseries/offsets/test_business_hour.py @@ -25,10 +25,7 @@ _testing as tm, date_range, ) -from pandas.tests.tseries.offsets.common import ( - Base, - assert_offset_equal, -) +from pandas.tests.tseries.offsets.common import assert_offset_equal @pytest.fixture @@ -36,29 +33,62 @@ def d(): return datetime(2014, 7, 1, 10, 00) -class TestBusinessHour(Base): - _offset: type[BusinessHour] = BusinessHour +@pytest.fixture +def _offset(): + return BusinessHour - def setup_method(self): - self.offset1 = BusinessHour() - self.offset2 = BusinessHour(n=3) - self.offset3 = BusinessHour(n=-1) - self.offset4 = BusinessHour(n=-4) +@pytest.fixture +def offset1(): + return BusinessHour() - from datetime import time as dt_time - self.offset5 = BusinessHour(start=dt_time(11, 0), end=dt_time(14, 30)) - self.offset6 = BusinessHour(start="20:00", end="05:00") - self.offset7 = BusinessHour(n=-2, start=dt_time(21, 30), end=dt_time(6, 30)) - self.offset8 = BusinessHour(start=["09:00", "13:00"], end=["12:00", "17:00"]) - self.offset9 = BusinessHour( - n=3, start=["09:00", "22:00"], end=["13:00", "03:00"] - ) - self.offset10 = BusinessHour( - n=-1, start=["23:00", "13:00"], end=["02:00", "17:00"] - ) +@pytest.fixture +def offset2(): + return BusinessHour(n=3) + + +@pytest.fixture +def offset3(): + return BusinessHour(n=-1) + + +@pytest.fixture +def offset4(): + return BusinessHour(n=-4) + + +@pytest.fixture +def offset5(): + return BusinessHour(start=dt_time(11, 0), end=dt_time(14, 30)) + + +@pytest.fixture +def offset6(): + return BusinessHour(start="20:00", end="05:00") + +@pytest.fixture +def offset7(): + return BusinessHour(n=-2, start=dt_time(21, 30), end=dt_time(6, 30)) + + +@pytest.fixture +def offset8(): + return BusinessHour(start=["09:00", "13:00"], end=["12:00", "17:00"]) + + +@pytest.fixture +def offset9(): + return BusinessHour(n=3, start=["09:00", "22:00"], end=["13:00", "03:00"]) + + +@pytest.fixture +def offset10(): + return BusinessHour(n=-1, start=["23:00", "13:00"], end=["02:00", "17:00"]) + + +class TestBusinessHour: @pytest.mark.parametrize( "start,end,match", [ @@ -99,24 +129,36 @@ def test_constructor_errors(self, start, end, match): with pytest.raises(ValueError, match=match): BusinessHour(start=start, end=end) - def test_different_normalize_equals(self): + def test_different_normalize_equals(self, _offset): # GH#21404 changed __eq__ to return False when `normalize` does not match - offset = self._offset() - offset2 = self._offset(normalize=True) + offset = _offset() + offset2 = _offset(normalize=True) assert offset != offset2 - def test_repr(self): - assert repr(self.offset1) == "" - assert repr(self.offset2) == "<3 * BusinessHours: BH=09:00-17:00>" - assert repr(self.offset3) == "<-1 * BusinessHour: BH=09:00-17:00>" - assert repr(self.offset4) == "<-4 * BusinessHours: BH=09:00-17:00>" + def test_repr( + self, + offset1, + offset2, + offset3, + offset4, + offset5, + offset6, + offset7, + offset8, + offset9, + offset10, + ): + assert repr(offset1) == "" + assert repr(offset2) == "<3 * BusinessHours: BH=09:00-17:00>" + assert repr(offset3) == "<-1 * BusinessHour: BH=09:00-17:00>" + assert repr(offset4) == "<-4 * BusinessHours: BH=09:00-17:00>" - assert repr(self.offset5) == "" - assert repr(self.offset6) == "" - assert repr(self.offset7) == "<-2 * BusinessHours: BH=21:30-06:30>" - assert repr(self.offset8) == "" - assert repr(self.offset9) == "<3 * BusinessHours: BH=09:00-13:00,22:00-03:00>" - assert repr(self.offset10) == "<-1 * BusinessHour: BH=13:00-17:00,23:00-02:00>" + assert repr(offset5) == "" + assert repr(offset6) == "" + assert repr(offset7) == "<-2 * BusinessHours: BH=21:30-06:30>" + assert repr(offset8) == "" + assert repr(offset9) == "<3 * BusinessHours: BH=09:00-13:00,22:00-03:00>" + assert repr(offset10) == "<-1 * BusinessHour: BH=13:00-17:00,23:00-02:00>" def test_with_offset(self, d): expected = Timestamp("2014-07-01 13:00") @@ -128,8 +170,8 @@ def test_with_offset(self, d): "offset_name", ["offset1", "offset2", "offset3", "offset4", "offset8", "offset9", "offset10"], ) - def test_eq_attribute(self, offset_name): - offset = getattr(self, offset_name) + def test_eq_attribute(self, offset_name, request): + offset = request.getfixturevalue(offset_name) assert offset == offset @pytest.mark.parametrize( @@ -167,91 +209,130 @@ def test_neq(self, offset1, offset2): "offset_name", ["offset1", "offset2", "offset3", "offset4", "offset8", "offset9", "offset10"], ) - def test_hash(self, offset_name): - offset = getattr(self, offset_name) + def test_hash(self, offset_name, request): + offset = request.getfixturevalue(offset_name) assert offset == offset - def test_call(self, d): + def test_call( + self, + d, + offset1, + offset2, + offset3, + offset4, + offset5, + offset6, + offset7, + offset8, + offset9, + offset10, + ): with tm.assert_produces_warning(FutureWarning): # GH#34171 DateOffset.__call__ is deprecated - assert self.offset1(d) == datetime(2014, 7, 1, 11) - assert self.offset2(d) == datetime(2014, 7, 1, 13) - assert self.offset3(d) == datetime(2014, 6, 30, 17) - assert self.offset4(d) == datetime(2014, 6, 30, 14) - assert self.offset8(d) == datetime(2014, 7, 1, 11) - assert self.offset9(d) == datetime(2014, 7, 1, 22) - assert self.offset10(d) == datetime(2014, 7, 1, 1) - - def test_sub(self, d): - # we have to override test_sub here because self.offset2 is not - # defined as self._offset(2) - off = self.offset2 + assert offset1(d) == datetime(2014, 7, 1, 11) + assert offset2(d) == datetime(2014, 7, 1, 13) + assert offset3(d) == datetime(2014, 6, 30, 17) + assert offset4(d) == datetime(2014, 6, 30, 14) + assert offset8(d) == datetime(2014, 7, 1, 11) + assert offset9(d) == datetime(2014, 7, 1, 22) + assert offset10(d) == datetime(2014, 7, 1, 1) + + def test_sub(self, d, offset2, _offset): + off = offset2 msg = "Cannot subtract datetime from offset" with pytest.raises(TypeError, match=msg): off - d assert 2 * off - off == off - assert d - self.offset2 == d + self._offset(-3) + assert d - offset2 == d + _offset(-3) - def testRollback1(self, d): - assert self.offset1.rollback(d) == d - assert self.offset2.rollback(d) == d - assert self.offset3.rollback(d) == d - assert self.offset4.rollback(d) == d - assert self.offset5.rollback(d) == datetime(2014, 6, 30, 14, 30) - assert self.offset6.rollback(d) == datetime(2014, 7, 1, 5, 0) - assert self.offset7.rollback(d) == datetime(2014, 7, 1, 6, 30) - assert self.offset8.rollback(d) == d - assert self.offset9.rollback(d) == d - assert self.offset10.rollback(d) == datetime(2014, 7, 1, 2) + def testRollback1( + self, + d, + _offset, + offset1, + offset2, + offset3, + offset4, + offset5, + offset6, + offset7, + offset8, + offset9, + offset10, + ): + assert offset1.rollback(d) == d + assert offset2.rollback(d) == d + assert offset3.rollback(d) == d + assert offset4.rollback(d) == d + assert offset5.rollback(d) == datetime(2014, 6, 30, 14, 30) + assert offset6.rollback(d) == datetime(2014, 7, 1, 5, 0) + assert offset7.rollback(d) == datetime(2014, 7, 1, 6, 30) + assert offset8.rollback(d) == d + assert offset9.rollback(d) == d + assert offset10.rollback(d) == datetime(2014, 7, 1, 2) datet = datetime(2014, 7, 1, 0) - assert self.offset1.rollback(datet) == datetime(2014, 6, 30, 17) - assert self.offset2.rollback(datet) == datetime(2014, 6, 30, 17) - assert self.offset3.rollback(datet) == datetime(2014, 6, 30, 17) - assert self.offset4.rollback(datet) == datetime(2014, 6, 30, 17) - assert self.offset5.rollback(datet) == datetime(2014, 6, 30, 14, 30) - assert self.offset6.rollback(datet) == datet - assert self.offset7.rollback(datet) == datet - assert self.offset8.rollback(datet) == datetime(2014, 6, 30, 17) - assert self.offset9.rollback(datet) == datet - assert self.offset10.rollback(datet) == datet - - assert self._offset(5).rollback(d) == d - - def testRollback2(self): - assert self._offset(-3).rollback(datetime(2014, 7, 5, 15, 0)) == datetime( + assert offset1.rollback(datet) == datetime(2014, 6, 30, 17) + assert offset2.rollback(datet) == datetime(2014, 6, 30, 17) + assert offset3.rollback(datet) == datetime(2014, 6, 30, 17) + assert offset4.rollback(datet) == datetime(2014, 6, 30, 17) + assert offset5.rollback(datet) == datetime(2014, 6, 30, 14, 30) + assert offset6.rollback(datet) == datet + assert offset7.rollback(datet) == datet + assert offset8.rollback(datet) == datetime(2014, 6, 30, 17) + assert offset9.rollback(datet) == datet + assert offset10.rollback(datet) == datet + + assert _offset(5).rollback(d) == d + + def testRollback2(self, _offset): + assert _offset(-3).rollback(datetime(2014, 7, 5, 15, 0)) == datetime( 2014, 7, 4, 17, 0 ) - def testRollforward1(self, d): - assert self.offset1.rollforward(d) == d - assert self.offset2.rollforward(d) == d - assert self.offset3.rollforward(d) == d - assert self.offset4.rollforward(d) == d - assert self.offset5.rollforward(d) == datetime(2014, 7, 1, 11, 0) - assert self.offset6.rollforward(d) == datetime(2014, 7, 1, 20, 0) - assert self.offset7.rollforward(d) == datetime(2014, 7, 1, 21, 30) - assert self.offset8.rollforward(d) == d - assert self.offset9.rollforward(d) == d - assert self.offset10.rollforward(d) == datetime(2014, 7, 1, 13) + def testRollforward1( + self, + d, + _offset, + offset1, + offset2, + offset3, + offset4, + offset5, + offset6, + offset7, + offset8, + offset9, + offset10, + ): + assert offset1.rollforward(d) == d + assert offset2.rollforward(d) == d + assert offset3.rollforward(d) == d + assert offset4.rollforward(d) == d + assert offset5.rollforward(d) == datetime(2014, 7, 1, 11, 0) + assert offset6.rollforward(d) == datetime(2014, 7, 1, 20, 0) + assert offset7.rollforward(d) == datetime(2014, 7, 1, 21, 30) + assert offset8.rollforward(d) == d + assert offset9.rollforward(d) == d + assert offset10.rollforward(d) == datetime(2014, 7, 1, 13) datet = datetime(2014, 7, 1, 0) - assert self.offset1.rollforward(datet) == datetime(2014, 7, 1, 9) - assert self.offset2.rollforward(datet) == datetime(2014, 7, 1, 9) - assert self.offset3.rollforward(datet) == datetime(2014, 7, 1, 9) - assert self.offset4.rollforward(datet) == datetime(2014, 7, 1, 9) - assert self.offset5.rollforward(datet) == datetime(2014, 7, 1, 11) - assert self.offset6.rollforward(datet) == datet - assert self.offset7.rollforward(datet) == datet - assert self.offset8.rollforward(datet) == datetime(2014, 7, 1, 9) - assert self.offset9.rollforward(datet) == datet - assert self.offset10.rollforward(datet) == datet - - assert self._offset(5).rollforward(d) == d - - def testRollforward2(self): - assert self._offset(-3).rollforward(datetime(2014, 7, 5, 16, 0)) == datetime( + assert offset1.rollforward(datet) == datetime(2014, 7, 1, 9) + assert offset2.rollforward(datet) == datetime(2014, 7, 1, 9) + assert offset3.rollforward(datet) == datetime(2014, 7, 1, 9) + assert offset4.rollforward(datet) == datetime(2014, 7, 1, 9) + assert offset5.rollforward(datet) == datetime(2014, 7, 1, 11) + assert offset6.rollforward(datet) == datet + assert offset7.rollforward(datet) == datet + assert offset8.rollforward(datet) == datetime(2014, 7, 1, 9) + assert offset9.rollforward(datet) == datet + assert offset10.rollforward(datet) == datet + + assert _offset(5).rollforward(d) == d + + def testRollforward2(self, _offset): + assert _offset(-3).rollforward(datetime(2014, 7, 5, 16, 0)) == datetime( 2014, 7, 7, 9 ) diff --git a/pandas/tests/tseries/offsets/test_business_month.py b/pandas/tests/tseries/offsets/test_business_month.py index db8aaab98a379..9f7fb990d238a 100644 --- a/pandas/tests/tseries/offsets/test_business_month.py +++ b/pandas/tests/tseries/offsets/test_business_month.py @@ -9,11 +9,8 @@ import pytest -from pandas._libs.tslibs.offsets import MonthOffset - import pandas as pd from pandas.tests.tseries.offsets.common import ( - Base, assert_is_on_offset, assert_offset_equal, ) @@ -47,9 +44,7 @@ def test_apply_index(cls, n): assert res2.iloc[-1] == ser.iloc[-1] + offset -class TestBMonthBegin(Base): - _offset: type[MonthOffset] = BMonthBegin - +class TestBMonthBegin: def test_offsets_compare_equal(self): # root cause of #456 offset1 = BMonthBegin() @@ -135,9 +130,7 @@ def test_is_on_offset(self, case): assert_is_on_offset(offset, dt, expected) -class TestBMonthEnd(Base): - _offset: type[MonthOffset] = BMonthEnd - +class TestBMonthEnd: def test_normalize(self): dt = datetime(2007, 1, 1, 3) diff --git a/pandas/tests/tseries/offsets/test_business_quarter.py b/pandas/tests/tseries/offsets/test_business_quarter.py index 5c50e080f71a8..44a7f16ab039d 100644 --- a/pandas/tests/tseries/offsets/test_business_quarter.py +++ b/pandas/tests/tseries/offsets/test_business_quarter.py @@ -9,10 +9,7 @@ import pytest -from pandas._libs.tslibs.offsets import QuarterOffset - from pandas.tests.tseries.offsets.common import ( - Base, assert_is_on_offset, assert_offset_equal, ) @@ -47,9 +44,7 @@ def test_on_offset(offset): assert res == slow_version -class TestBQuarterBegin(Base): - _offset: type[QuarterOffset] = BQuarterBegin - +class TestBQuarterBegin: def test_repr(self): expected = "" assert repr(BQuarterBegin()) == expected @@ -172,9 +167,7 @@ def test_offset(self, case): assert_offset_equal(offset, base, expected) -class TestBQuarterEnd(Base): - _offset: type[QuarterOffset] = BQuarterEnd - +class TestBQuarterEnd: def test_repr(self): expected = "" assert repr(BQuarterEnd()) == expected diff --git a/pandas/tests/tseries/offsets/test_business_year.py b/pandas/tests/tseries/offsets/test_business_year.py index 21778acd78bfd..3b7a1025cc19c 100644 --- a/pandas/tests/tseries/offsets/test_business_year.py +++ b/pandas/tests/tseries/offsets/test_business_year.py @@ -9,10 +9,7 @@ import pytest -from pandas._libs.tslibs.offsets import YearOffset - from pandas.tests.tseries.offsets.common import ( - Base, assert_is_on_offset, assert_offset_equal, ) @@ -23,9 +20,7 @@ ) -class TestBYearBegin(Base): - _offset: type[YearOffset] = BYearBegin - +class TestBYearBegin: def test_misspecified(self): msg = "Month must go from 1 to 12" with pytest.raises(ValueError, match=msg): @@ -96,9 +91,7 @@ def test_offset(self, case): assert_offset_equal(offset, base, expected) -class TestBYearEnd(Base): - _offset: type[YearOffset] = BYearEnd - +class TestBYearEnd: offset_cases = [] offset_cases.append( ( @@ -169,9 +162,7 @@ def test_is_on_offset(self, case): assert_is_on_offset(offset, dt, expected) -class TestBYearEndLagged(Base): - _offset: type[YearOffset] = BYearEnd - +class TestBYearEndLagged: def test_bad_month_fail(self): msg = "Month must go from 1 to 12" with pytest.raises(ValueError, match=msg): diff --git a/pandas/tests/tseries/offsets/test_custom_business_day.py b/pandas/tests/tseries/offsets/test_custom_business_day.py index 1d6a39fbfa3e3..519fb712d0415 100644 --- a/pandas/tests/tseries/offsets/test_custom_business_day.py +++ b/pandas/tests/tseries/offsets/test_custom_business_day.py @@ -31,8 +31,6 @@ def offset2(): class TestCustomBusinessDay: - _offset = CDay - def test_repr(self, offset, offset2): assert repr(offset) == "" assert repr(offset2) == "<2 * CustomBusinessDays>" diff --git a/pandas/tests/tseries/offsets/test_custom_business_hour.py b/pandas/tests/tseries/offsets/test_custom_business_hour.py index 29ffd9dca6b34..56c4d248a278c 100644 --- a/pandas/tests/tseries/offsets/test_custom_business_hour.py +++ b/pandas/tests/tseries/offsets/test_custom_business_hour.py @@ -3,7 +3,10 @@ """ from __future__ import annotations -from datetime import datetime +from datetime import ( + datetime, + time as dt_time, +) import numpy as np import pytest @@ -16,36 +19,40 @@ ) import pandas._testing as tm -from pandas.tests.tseries.offsets.common import ( - Base, - assert_offset_equal, -) +from pandas.tests.tseries.offsets.common import assert_offset_equal from pandas.tseries.holiday import USFederalHolidayCalendar +holidays = ["2014-06-27", datetime(2014, 6, 30), np.datetime64("2014-07-02")] + @pytest.fixture def d(): return datetime(2014, 7, 1, 10, 00) -class TestCustomBusinessHour(Base): - _offset: type[CustomBusinessHour] = CustomBusinessHour - holidays = ["2014-06-27", datetime(2014, 6, 30), np.datetime64("2014-07-02")] +@pytest.fixture +def _offset(): + return CustomBusinessHour - def setup_method(self): - # 2014 Calendar to check custom holidays - # Sun Mon Tue Wed Thu Fri Sat - # 6/22 23 24 25 26 27 28 - # 29 30 7/1 2 3 4 5 - # 6 7 8 9 10 11 12 - self.offset1 = CustomBusinessHour(weekmask="Tue Wed Thu Fri") - self.offset2 = CustomBusinessHour(holidays=self.holidays) +# 2014 Calendar to check custom holidays +# Sun Mon Tue Wed Thu Fri Sat +# 6/22 23 24 25 26 27 28 +# 29 30 7/1 2 3 4 5 +# 6 7 8 9 10 11 12 +@pytest.fixture +def offset1(): + return CustomBusinessHour(weekmask="Tue Wed Thu Fri") - def test_constructor_errors(self): - from datetime import time as dt_time +@pytest.fixture +def offset2(): + return CustomBusinessHour(holidays=holidays) + + +class TestCustomBusinessHour: + def test_constructor_errors(self): msg = "time data must be specified only with hour and minute" with pytest.raises(ValueError, match=msg): CustomBusinessHour(start=dt_time(11, 0, 5)) @@ -56,15 +63,15 @@ def test_constructor_errors(self): with pytest.raises(ValueError, match=msg): CustomBusinessHour(start="14:00:05") - def test_different_normalize_equals(self): + def test_different_normalize_equals(self, _offset): # GH#21404 changed __eq__ to return False when `normalize` does not match - offset = self._offset() - offset2 = self._offset(normalize=True) + offset = _offset() + offset2 = _offset(normalize=True) assert offset != offset2 - def test_repr(self): - assert repr(self.offset1) == "" - assert repr(self.offset2) == "" + def test_repr(self, offset1, offset2): + assert repr(offset1) == "" + assert repr(offset2) == "" def test_with_offset(self, d): expected = Timestamp("2014-07-01 13:00") @@ -72,8 +79,8 @@ def test_with_offset(self, d): assert d + CustomBusinessHour() * 3 == expected assert d + CustomBusinessHour(n=3) == expected - def test_eq(self): - for offset in [self.offset1, self.offset2]: + def test_eq(self, offset1, offset2): + for offset in [offset1, offset2]: assert offset == offset assert CustomBusinessHour() != CustomBusinessHour(-1) @@ -90,43 +97,43 @@ def test_eq(self): holidays=["2014-06-28"] ) - def test_hash(self): - assert hash(self.offset1) == hash(self.offset1) - assert hash(self.offset2) == hash(self.offset2) + def test_hash(self, offset1, offset2): + assert hash(offset1) == hash(offset1) + assert hash(offset2) == hash(offset2) - def test_call(self, d): + def test_call(self, d, offset1, offset2): with tm.assert_produces_warning(FutureWarning): # GH#34171 DateOffset.__call__ is deprecated - assert self.offset1(d) == datetime(2014, 7, 1, 11) - assert self.offset2(d) == datetime(2014, 7, 1, 11) + assert offset1(d) == datetime(2014, 7, 1, 11) + assert offset2(d) == datetime(2014, 7, 1, 11) - def testRollback1(self, d): - assert self.offset1.rollback(d) == d - assert self.offset2.rollback(d) == d + def testRollback1(self, d, offset1, offset2): + assert offset1.rollback(d) == d + assert offset2.rollback(d) == d d = datetime(2014, 7, 1, 0) # 2014/07/01 is Tuesday, 06/30 is Monday(holiday) - assert self.offset1.rollback(d) == datetime(2014, 6, 27, 17) + assert offset1.rollback(d) == datetime(2014, 6, 27, 17) # 2014/6/30 and 2014/6/27 are holidays - assert self.offset2.rollback(d) == datetime(2014, 6, 26, 17) + assert offset2.rollback(d) == datetime(2014, 6, 26, 17) - def testRollback2(self): - assert self._offset(-3).rollback(datetime(2014, 7, 5, 15, 0)) == datetime( + def testRollback2(self, _offset): + assert _offset(-3).rollback(datetime(2014, 7, 5, 15, 0)) == datetime( 2014, 7, 4, 17, 0 ) - def testRollforward1(self, d): - assert self.offset1.rollforward(d) == d - assert self.offset2.rollforward(d) == d + def testRollforward1(self, d, offset1, offset2): + assert offset1.rollforward(d) == d + assert offset2.rollforward(d) == d d = datetime(2014, 7, 1, 0) - assert self.offset1.rollforward(d) == datetime(2014, 7, 1, 9) - assert self.offset2.rollforward(d) == datetime(2014, 7, 1, 9) + assert offset1.rollforward(d) == datetime(2014, 7, 1, 9) + assert offset2.rollforward(d) == datetime(2014, 7, 1, 9) - def testRollforward2(self): - assert self._offset(-3).rollforward(datetime(2014, 7, 5, 16, 0)) == datetime( + def testRollforward2(self, _offset): + assert _offset(-3).rollforward(datetime(2014, 7, 5, 16, 0)) == datetime( 2014, 7, 7, 9 ) @@ -195,24 +202,20 @@ def test_normalize(self, norm_cases): for dt, expected in cases.items(): assert offset._apply(dt) == expected - def test_is_on_offset(self): - tests = [ - ( - CustomBusinessHour(start="10:00", end="15:00", holidays=self.holidays), - { - datetime(2014, 7, 1, 9): False, - datetime(2014, 7, 1, 10): True, - datetime(2014, 7, 1, 15): True, - datetime(2014, 7, 1, 15, 1): False, - datetime(2014, 7, 5, 12): False, - datetime(2014, 7, 6, 12): False, - }, - ) - ] - - for offset, cases in tests: - for dt, expected in cases.items(): - assert offset.is_on_offset(dt) == expected + @pytest.mark.parametrize( + "dt, expected", + [ + [datetime(2014, 7, 1, 9), False], + [datetime(2014, 7, 1, 10), True], + [datetime(2014, 7, 1, 15), True], + [datetime(2014, 7, 1, 15, 1), False], + [datetime(2014, 7, 5, 12), False], + [datetime(2014, 7, 6, 12), False], + ], + ) + def test_is_on_offset(self, dt, expected): + offset = CustomBusinessHour(start="10:00", end="15:00", holidays=holidays) + assert offset.is_on_offset(dt) == expected apply_cases = [ ( diff --git a/pandas/tests/tseries/offsets/test_custom_business_month.py b/pandas/tests/tseries/offsets/test_custom_business_month.py index 460d1e20b63ca..9c16ce1d7dd65 100644 --- a/pandas/tests/tseries/offsets/test_custom_business_month.py +++ b/pandas/tests/tseries/offsets/test_custom_business_month.py @@ -19,7 +19,6 @@ CBMonthBegin, CBMonthEnd, CDay, - _CustomBusinessMonth, ) from pandas import ( @@ -27,7 +26,6 @@ date_range, ) from pandas.tests.tseries.offsets.common import ( - Base, assert_is_on_offset, assert_offset_equal, ) @@ -42,50 +40,59 @@ def d(): return datetime(2008, 1, 1) -class CustomBusinessMonthBase: - def setup_method(self): - self.offset = self._offset() - self.offset1 = self.offset - self.offset2 = self._offset(2) +class TestCommonCBM: + @pytest.mark.parametrize("offset2", [CBMonthBegin(2), CBMonthEnd(2)]) + def test_eq(self, offset2): + assert offset2 == offset2 - def test_eq(self): - assert self.offset2 == self.offset2 + @pytest.mark.parametrize("offset2", [CBMonthBegin(2), CBMonthEnd(2)]) + def test_hash(self, offset2): + assert hash(offset2) == hash(offset2) - def test_hash(self): - assert hash(self.offset2) == hash(self.offset2) - - def test_roundtrip_pickle(self): + @pytest.mark.parametrize("_offset", [CBMonthBegin, CBMonthEnd]) + def test_roundtrip_pickle(self, _offset): def _check_roundtrip(obj): unpickled = tm.round_trip_pickle(obj) assert unpickled == obj - _check_roundtrip(self._offset()) - _check_roundtrip(self._offset(2)) - _check_roundtrip(self._offset() * 2) + _check_roundtrip(_offset()) + _check_roundtrip(_offset(2)) + _check_roundtrip(_offset() * 2) - def test_copy(self): + @pytest.mark.parametrize("_offset", [CBMonthBegin, CBMonthEnd]) + def test_copy(self, _offset): # GH 17452 - off = self._offset(weekmask="Mon Wed Fri") + off = _offset(weekmask="Mon Wed Fri") assert off == off.copy() -class TestCustomBusinessMonthBegin(CustomBusinessMonthBase, Base): - _offset: type[_CustomBusinessMonth] = CBMonthBegin +class TestCustomBusinessMonthBegin: + @pytest.fixture + def _offset(self): + return CBMonthBegin + + @pytest.fixture + def offset(self): + return CBMonthBegin() + + @pytest.fixture + def offset2(self): + return CBMonthBegin(2) - def test_different_normalize_equals(self): + def test_different_normalize_equals(self, _offset): # GH#21404 changed __eq__ to return False when `normalize` does not match - offset = self._offset() - offset2 = self._offset(normalize=True) + offset = _offset() + offset2 = _offset(normalize=True) assert offset != offset2 - def test_repr(self): - assert repr(self.offset) == "" - assert repr(self.offset2) == "<2 * CustomBusinessMonthBegins>" + def test_repr(self, offset, offset2): + assert repr(offset) == "" + assert repr(offset2) == "<2 * CustomBusinessMonthBegins>" - def test_call(self, d): + def test_call(self, d, offset2): with tm.assert_produces_warning(FutureWarning): # GH#34171 DateOffset.__call__ is deprecated - assert self.offset2(d) == datetime(2008, 3, 3) + assert offset2(d) == datetime(2008, 3, 3) def testRollback1(self): assert CDay(10).rollback(datetime(2007, 12, 31)) == datetime(2007, 12, 31) @@ -259,23 +266,33 @@ def test_apply_with_extra_offset(self, case): assert_offset_equal(offset, base, expected) -class TestCustomBusinessMonthEnd(CustomBusinessMonthBase, Base): - _offset: type[_CustomBusinessMonth] = CBMonthEnd +class TestCustomBusinessMonthEnd: + @pytest.fixture + def _offset(self): + return CBMonthEnd + + @pytest.fixture + def offset(self): + return CBMonthEnd() + + @pytest.fixture + def offset2(self): + return CBMonthEnd(2) - def test_different_normalize_equals(self): + def test_different_normalize_equals(self, _offset): # GH#21404 changed __eq__ to return False when `normalize` does not match - offset = self._offset() - offset2 = self._offset(normalize=True) + offset = _offset() + offset2 = _offset(normalize=True) assert offset != offset2 - def test_repr(self): - assert repr(self.offset) == "" - assert repr(self.offset2) == "<2 * CustomBusinessMonthEnds>" + def test_repr(self, offset, offset2): + assert repr(offset) == "" + assert repr(offset2) == "<2 * CustomBusinessMonthEnds>" - def test_call(self, d): + def test_call(self, d, offset2): with tm.assert_produces_warning(FutureWarning): # GH#34171 DateOffset.__call__ is deprecated - assert self.offset2(d) == datetime(2008, 2, 29) + assert offset2(d) == datetime(2008, 2, 29) def testRollback1(self): assert CDay(10).rollback(datetime(2007, 12, 31)) == datetime(2007, 12, 31) diff --git a/pandas/tests/tseries/offsets/test_easter.py b/pandas/tests/tseries/offsets/test_easter.py index 90ee7c7f69d5e..d11a72cc1b9d5 100644 --- a/pandas/tests/tseries/offsets/test_easter.py +++ b/pandas/tests/tseries/offsets/test_easter.py @@ -8,15 +8,12 @@ import pytest -from pandas.tests.tseries.offsets.common import ( - Base, - assert_offset_equal, -) +from pandas.tests.tseries.offsets.common import assert_offset_equal from pandas.tseries.offsets import Easter -class TestEaster(Base): +class TestEaster: @pytest.mark.parametrize( "offset,date,expected", [ diff --git a/pandas/tests/tseries/offsets/test_fiscal.py b/pandas/tests/tseries/offsets/test_fiscal.py index 8df93102d4bd2..d0801b2cede29 100644 --- a/pandas/tests/tseries/offsets/test_fiscal.py +++ b/pandas/tests/tseries/offsets/test_fiscal.py @@ -11,7 +11,6 @@ from pandas import Timestamp import pandas._testing as tm from pandas.tests.tseries.offsets.common import ( - Base, WeekDay, assert_is_on_offset, assert_offset_equal, @@ -95,7 +94,7 @@ def test_get_offset(): ) -class TestFY5253LastOfMonth(Base): +class TestFY5253LastOfMonth: offset_lom_sat_aug = makeFY5253LastOfMonth(1, startingMonth=8, weekday=WeekDay.SAT) offset_lom_sat_sep = makeFY5253LastOfMonth(1, startingMonth=9, weekday=WeekDay.SAT) @@ -180,7 +179,7 @@ def test_apply(self): assert current == datum -class TestFY5253NearestEndMonth(Base): +class TestFY5253NearestEndMonth: def test_get_year_end(self): assert makeFY5253NearestEndMonth( startingMonth=8, weekday=WeekDay.SAT @@ -338,7 +337,7 @@ def test_apply(self): assert current == datum -class TestFY5253LastOfMonthQuarter(Base): +class TestFY5253LastOfMonthQuarter: def test_is_anchored(self): assert makeFY5253LastOfMonthQuarter( startingMonth=1, weekday=WeekDay.SAT, qtr_with_extra_week=4 @@ -554,7 +553,7 @@ def test_get_weeks(self): assert sat_dec_1.get_weeks(datetime(2010, 12, 25)) == [13, 13, 13, 13] -class TestFY5253NearestEndMonthQuarter(Base): +class TestFY5253NearestEndMonthQuarter: offset_nem_sat_aug_4 = makeFY5253NearestEndMonthQuarter( 1, startingMonth=8, weekday=WeekDay.SAT, qtr_with_extra_week=4 diff --git a/pandas/tests/tseries/offsets/test_month.py b/pandas/tests/tseries/offsets/test_month.py index 305b57cea17b1..a1b7f710c3b24 100644 --- a/pandas/tests/tseries/offsets/test_month.py +++ b/pandas/tests/tseries/offsets/test_month.py @@ -15,10 +15,8 @@ from pandas._libs.tslibs.offsets import ( MonthBegin, MonthEnd, - MonthOffset, SemiMonthBegin, SemiMonthEnd, - SemiMonthOffset, ) from pandas import ( @@ -28,17 +26,12 @@ date_range, ) from pandas.tests.tseries.offsets.common import ( - Base, assert_is_on_offset, assert_offset_equal, ) -class TestSemiMonthEnd(Base): - _offset: type[SemiMonthOffset] = SemiMonthEnd - offset1 = _offset() - offset2 = _offset(2) - +class TestSemiMonthEnd: def test_offset_whole_year(self): dates = ( datetime(2007, 12, 31), @@ -298,11 +291,7 @@ def test_vectorized_offset_addition(self, klass): tm.assert_equal(result2, exp) -class TestSemiMonthBegin(Base): - _offset: type[SemiMonthOffset] = SemiMonthBegin - offset1 = _offset() - offset2 = _offset(2) - +class TestSemiMonthBegin: def test_offset_whole_year(self): dates = ( datetime(2007, 12, 15), @@ -538,8 +527,7 @@ def test_vectorized_offset_addition(self, klass): tm.assert_equal(result2, exp) -class TestMonthBegin(Base): - _offset: type[MonthOffset] = MonthBegin +class TestMonthBegin: offset_cases = [] # NOTE: I'm not entirely happy with the logic here for Begin -ss @@ -603,9 +591,7 @@ def test_offset(self, case): assert_offset_equal(offset, base, expected) -class TestMonthEnd(Base): - _offset: type[MonthOffset] = MonthEnd - +class TestMonthEnd: def test_day_of_month(self): dt = datetime(2007, 1, 1) offset = MonthEnd() diff --git a/pandas/tests/tseries/offsets/test_offsets.py b/pandas/tests/tseries/offsets/test_offsets.py index 14e65bba17a7d..51282e6c2019d 100644 --- a/pandas/tests/tseries/offsets/test_offsets.py +++ b/pandas/tests/tseries/offsets/test_offsets.py @@ -38,10 +38,7 @@ date_range, ) import pandas._testing as tm -from pandas.tests.tseries.offsets.common import ( - Base, - WeekDay, -) +from pandas.tests.tseries.offsets.common import WeekDay import pandas.tseries.offsets as offsets from pandas.tseries.offsets import ( @@ -80,16 +77,49 @@ ] +def _create_offset(klass, value=1, normalize=False): + # create instance from offset class + if klass is FY5253: + klass = klass( + n=value, + startingMonth=1, + weekday=1, + variation="last", + normalize=normalize, + ) + elif klass is FY5253Quarter: + klass = klass( + n=value, + startingMonth=1, + weekday=1, + qtr_with_extra_week=1, + variation="last", + normalize=normalize, + ) + elif klass is LastWeekOfMonth: + klass = klass(n=value, weekday=5, normalize=normalize) + elif klass is WeekOfMonth: + klass = klass(n=value, week=1, weekday=5, normalize=normalize) + elif klass is Week: + klass = klass(n=value, weekday=5, normalize=normalize) + elif klass is DateOffset: + klass = klass(days=value, normalize=normalize) + else: + klass = klass(value, normalize=normalize) + return klass + + @pytest.fixture def d(): return Timestamp(datetime(2008, 1, 2)) -class TestCommon(Base): - # executed value created by Base._get_offset +@pytest.fixture +def expecteds(): + # executed value created by _create_offset # are applied to 2011/01/01 09:00 (Saturday) # used for .apply and .rollforward - expecteds = { + return { "Day": Timestamp("2011-01-02 09:00:00"), "DateOffset": Timestamp("2011-01-02 09:00:00"), "BusinessDay": Timestamp("2011-01-03 09:00:00"), @@ -126,9 +156,11 @@ class TestCommon(Base): "Nano": Timestamp("2011-01-01T09:00:00.000000001"), } + +class TestCommon: def test_immutable(self, offset_types): # GH#21341 check that __setattr__ raises - offset = self._get_offset(offset_types) + offset = _create_offset(offset_types) msg = "objects is not writable|DateOffset objects are immutable" with pytest.raises(AttributeError, match=msg): offset.normalize = True @@ -136,7 +168,7 @@ def test_immutable(self, offset_types): offset.n = 91 def test_return_type(self, offset_types): - offset = self._get_offset(offset_types) + offset = _create_offset(offset_types) # make sure that we are returning a Timestamp result = Timestamp("20080101") + offset @@ -150,7 +182,7 @@ def test_return_type(self, offset_types): assert (-offset)._apply(NaT) is NaT def test_offset_n(self, offset_types): - offset = self._get_offset(offset_types) + offset = _create_offset(offset_types) assert offset.n == 1 neg_offset = offset * -1 @@ -162,14 +194,14 @@ def test_offset_n(self, offset_types): 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) + off = _create_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) + off = _create_offset(offset_types) expected = np.array([[off, off * 2], [off * 3, off * 4]]) @@ -180,7 +212,7 @@ def test_offset_mul_ndarray(self, offset_types): tm.assert_numpy_array_equal(result, expected) def test_offset_freqstr(self, offset_types): - offset = self._get_offset(offset_types) + offset = _create_offset(offset_types) freqstr = offset.freqstr if freqstr not in ("", "", "LWOM-SAT"): @@ -193,7 +225,7 @@ def _check_offsetfunc_works(self, offset, funcname, dt, expected, normalize=Fals # normalize=True disallowed for Tick subclasses GH#21427 return - offset_s = self._get_offset(offset, normalize=normalize) + offset_s = _create_offset(offset, normalize=normalize) func = getattr(offset_s, funcname) result = func(dt) @@ -279,11 +311,11 @@ def _check_offsetfunc_works(self, offset, funcname, dt, expected, normalize=Fals else: assert result == expected_localize - def test_apply(self, offset_types): + def test_apply(self, offset_types, expecteds): sdt = datetime(2011, 1, 1, 9, 0) ndt = np.datetime64("2011-01-01 09:00") - expected = self.expecteds[offset_types.__name__] + expected = expecteds[offset_types.__name__] expected_norm = Timestamp(expected.date()) for dt in [sdt, ndt]: @@ -293,8 +325,8 @@ def test_apply(self, offset_types): offset_types, "_apply", dt, expected_norm, normalize=True ) - def test_rollforward(self, offset_types): - expecteds = self.expecteds.copy() + def test_rollforward(self, offset_types, expecteds): + expecteds = expecteds.copy() # result will not be changed if the target is on the offset no_changes = [ @@ -423,16 +455,16 @@ def test_rollback(self, offset_types): 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) + def test_is_on_offset(self, offset_types, expecteds): + dt = expecteds[offset_types.__name__] + offset_s = _create_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) + offset_n = _create_offset(offset_types, normalize=True) assert not offset_n.is_on_offset(dt) if offset_types in (BusinessHour, CustomBusinessHour): @@ -442,12 +474,12 @@ def test_is_on_offset(self, offset_types): date = datetime(dt.year, dt.month, dt.day) assert offset_n.is_on_offset(date) - def test_add(self, offset_types, tz_naive_fixture): + def test_add(self, offset_types, tz_naive_fixture, expecteds): tz = tz_naive_fixture dt = datetime(2011, 1, 1, 9, 0) - offset_s = self._get_offset(offset_types) - expected = self.expecteds[offset_types.__name__] + offset_s = _create_offset(offset_types) + expected = expecteds[offset_types.__name__] result_dt = dt + offset_s result_ts = Timestamp(dt) + offset_s @@ -463,7 +495,7 @@ def test_add(self, offset_types, tz_naive_fixture): # normalize=True, disallowed for Tick subclasses GH#21427 if issubclass(offset_types, Tick): return - offset_s = self._get_offset(offset_types, normalize=True) + offset_s = _create_offset(offset_types, normalize=True) expected = Timestamp(expected.date()) result_dt = dt + offset_s @@ -479,7 +511,7 @@ def test_add(self, offset_types, tz_naive_fixture): def test_add_empty_datetimeindex(self, offset_types, tz_naive_fixture): # GH#12724, GH#30336 - offset_s = self._get_offset(offset_types) + offset_s = _create_offset(offset_types) dti = DatetimeIndex([], tz=tz_naive_fixture) @@ -518,7 +550,7 @@ def test_add_empty_datetimeindex(self, offset_types, tz_naive_fixture): tm.assert_equal(result, dta) def test_pickle_roundtrip(self, offset_types): - off = self._get_offset(offset_types) + off = _create_offset(offset_types) res = tm.round_trip_pickle(off) assert off == res if type(off) is not DateOffset: @@ -541,7 +573,7 @@ def test_pickle_dateoffset_odd_inputs(self): def test_onOffset_deprecated(self, offset_types, fixed_now_ts): # GH#30340 use idiomatic naming - off = self._get_offset(offset_types) + off = _create_offset(offset_types) ts = fixed_now_ts with tm.assert_produces_warning(FutureWarning): @@ -552,7 +584,7 @@ def test_onOffset_deprecated(self, offset_types, fixed_now_ts): def test_isAnchored_deprecated(self, offset_types): # GH#30340 use idiomatic naming - off = self._get_offset(offset_types) + off = _create_offset(offset_types) with tm.assert_produces_warning(FutureWarning): result = off.isAnchored() @@ -562,13 +594,13 @@ def test_isAnchored_deprecated(self, offset_types): def test_offsets_hashable(self, offset_types): # GH: 37267 - off = self._get_offset(offset_types) + off = _create_offset(offset_types) assert hash(off) is not None @pytest.mark.parametrize("unit", ["s", "ms", "us"]) def test_add_dt64_ndarray_non_nano(self, offset_types, unit, request): # check that the result with non-nano matches nano - off = self._get_offset(offset_types) + off = _create_offset(offset_types) dti = date_range("2016-01-01", periods=35, freq="D") @@ -598,7 +630,7 @@ def test_add_dt64_ndarray_non_nano(self, offset_types, unit, request): tm.assert_numpy_array_equal(result._ndarray, expected._ndarray) -class TestDateOffset(Base): +class TestDateOffset: def setup_method(self): _offset_map.clear() diff --git a/pandas/tests/tseries/offsets/test_quarter.py b/pandas/tests/tseries/offsets/test_quarter.py index 9063b71cdece4..d183645da507d 100644 --- a/pandas/tests/tseries/offsets/test_quarter.py +++ b/pandas/tests/tseries/offsets/test_quarter.py @@ -10,7 +10,6 @@ import pytest from pandas.tests.tseries.offsets.common import ( - Base, assert_is_on_offset, assert_offset_equal, ) @@ -21,31 +20,30 @@ ) -def test_quarterly_dont_normalize(): +@pytest.mark.parametrize("klass", (QuarterBegin, QuarterEnd)) +def test_quarterly_dont_normalize(klass): date = datetime(2012, 3, 31, 5, 30) - - offsets = (QuarterBegin, QuarterEnd) - - for klass in offsets: - result = date + klass() - assert result.time() == date.time() + result = date + klass() + assert result.time() == date.time() @pytest.mark.parametrize("offset", [QuarterBegin(), QuarterEnd()]) -def test_on_offset(offset): - dates = [ +@pytest.mark.parametrize( + "date", + [ datetime(2016, m, d) for m in [10, 11, 12] for d in [1, 2, 3, 28, 29, 30, 31] if not (m == 11 and d == 31) - ] - for date in dates: - res = offset.is_on_offset(date) - slow_version = date == (date + offset) - offset - assert res == slow_version + ], +) +def test_on_offset(offset, date): + res = offset.is_on_offset(date) + slow_version = date == (date + offset) - offset + assert res == slow_version -class TestQuarterBegin(Base): +class TestQuarterBegin: def test_repr(self): expected = "" assert repr(QuarterBegin()) == expected @@ -153,9 +151,7 @@ def test_offset(self, case): assert_offset_equal(offset, base, expected) -class TestQuarterEnd(Base): - _offset: type[QuarterEnd] = QuarterEnd - +class TestQuarterEnd: def test_repr(self): expected = "" assert repr(QuarterEnd()) == expected diff --git a/pandas/tests/tseries/offsets/test_week.py b/pandas/tests/tseries/offsets/test_week.py index fcf11899d8a56..51eb662967db6 100644 --- a/pandas/tests/tseries/offsets/test_week.py +++ b/pandas/tests/tseries/offsets/test_week.py @@ -19,23 +19,16 @@ LastWeekOfMonth, Week, WeekOfMonth, - WeekOfMonthMixin, ) from pandas.tests.tseries.offsets.common import ( - Base, WeekDay, assert_is_on_offset, assert_offset_equal, ) -class TestWeek(Base): - _offset: type[Week] = Week - d = Timestamp(datetime(2008, 1, 2)) - offset1 = _offset() - offset2 = _offset(2) - +class TestWeek: def test_repr(self): assert repr(Week(weekday=0)) == "" assert repr(Week(n=-1, weekday=0)) == "<-1 * Week: weekday=0>" @@ -153,11 +146,7 @@ def test_week_add_invalid(self): offset + other -class TestWeekOfMonth(Base): - _offset: type[WeekOfMonthMixin] = WeekOfMonth - offset1 = _offset() - offset2 = _offset(2) - +class TestWeekOfMonth: def test_constructor(self): with pytest.raises(ValueError, match="^Week"): WeekOfMonth(n=1, week=4, weekday=0) @@ -269,11 +258,7 @@ def test_is_on_offset_nanoseconds(self, n, week, date, tz): assert fast == slow -class TestLastWeekOfMonth(Base): - _offset: type[WeekOfMonthMixin] = LastWeekOfMonth - offset1 = _offset() - offset2 = _offset(2) - +class TestLastWeekOfMonth: def test_constructor(self): with pytest.raises(ValueError, match="^N cannot be 0"): LastWeekOfMonth(n=0, weekday=1) diff --git a/pandas/tests/tseries/offsets/test_year.py b/pandas/tests/tseries/offsets/test_year.py index 55c3057b23cb0..daa5171af2452 100644 --- a/pandas/tests/tseries/offsets/test_year.py +++ b/pandas/tests/tseries/offsets/test_year.py @@ -9,10 +9,7 @@ import pytest -from pandas._libs.tslibs.offsets import YearOffset - from pandas.tests.tseries.offsets.common import ( - Base, assert_is_on_offset, assert_offset_equal, ) @@ -23,9 +20,7 @@ ) -class TestYearBegin(Base): - _offset: type[YearOffset] = YearBegin - +class TestYearBegin: def test_misspecified(self): with pytest.raises(ValueError, match="Month must go from 1 to 12"): YearBegin(month=13) @@ -177,9 +172,7 @@ def test_is_on_offset(self, case): assert_is_on_offset(offset, dt, expected) -class TestYearEnd(Base): - _offset: type[YearOffset] = YearEnd - +class TestYearEnd: def test_misspecified(self): with pytest.raises(ValueError, match="Month must go from 1 to 12"): YearEnd(month=13) @@ -254,7 +247,7 @@ def test_is_on_offset(self, case): assert_is_on_offset(offset, dt, expected) -class TestYearEndDiffMonth(Base): +class TestYearEndDiffMonth: offset_cases = [] offset_cases.append( ( From 504709dc8372eb678fb800b52c260f7804bae2b7 Mon Sep 17 00:00:00 2001 From: Matthew Roeschke <10647082+mroeschke@users.noreply.github.com> Date: Fri, 21 Oct 2022 10:55:35 -0700 Subject: [PATCH 3/3] d -> dt --- pandas/tests/tseries/offsets/conftest.py | 2 +- .../tseries/offsets/test_business_day.py | 22 ++--- .../tseries/offsets/test_business_hour.py | 80 +++++++++---------- pandas/tests/tseries/offsets/test_common.py | 8 +- .../offsets/test_custom_business_hour.py | 26 +++--- .../offsets/test_custom_business_month.py | 30 +++---- pandas/tests/tseries/offsets/test_offsets.py | 34 ++++---- 7 files changed, 101 insertions(+), 101 deletions(-) diff --git a/pandas/tests/tseries/offsets/conftest.py b/pandas/tests/tseries/offsets/conftest.py index ee6da4a9789fe..b07771af4e1c1 100644 --- a/pandas/tests/tseries/offsets/conftest.py +++ b/pandas/tests/tseries/offsets/conftest.py @@ -35,7 +35,7 @@ def month_classes(request): @pytest.fixture -def d(): +def dt(): """ Fixture for common Timestamp. """ diff --git a/pandas/tests/tseries/offsets/test_business_day.py b/pandas/tests/tseries/offsets/test_business_day.py index 448f35d8ec525..a03a16ce7ffe7 100644 --- a/pandas/tests/tseries/offsets/test_business_day.py +++ b/pandas/tests/tseries/offsets/test_business_day.py @@ -32,7 +32,7 @@ @pytest.fixture -def d(): +def dt(): return datetime(2008, 1, 1) @@ -65,10 +65,10 @@ def test_repr(self, offset, offset2): expected = "" assert repr(offset + timedelta(1)) == expected - def test_with_offset(self, d, offset): + def test_with_offset(self, dt, offset): offset = offset + timedelta(hours=2) - assert (d + offset) == datetime(2008, 1, 2, 2) + assert (dt + offset) == datetime(2008, 1, 2, 2) @pytest.mark.parametrize( "td", @@ -79,9 +79,9 @@ def test_with_offset(self, d, offset): ], ids=lambda x: type(x), ) - def test_with_offset_index(self, td, d, offset): + def test_with_offset_index(self, td, dt, offset): - dti = DatetimeIndex([d]) + dti = DatetimeIndex([dt]) expected = DatetimeIndex([datetime(2008, 1, 2, 2)]) result = dti + (td + offset) @@ -96,20 +96,20 @@ def test_eq(self, offset2): def test_hash(self, offset2): assert hash(offset2) == hash(offset2) - def test_call(self, d, offset2): + def test_call(self, dt, offset2): with tm.assert_produces_warning(FutureWarning): # GH#34171 DateOffset.__call__ is deprecated - assert offset2(d) == datetime(2008, 1, 3) + assert offset2(dt) == datetime(2008, 1, 3) assert offset2(np.datetime64("2008-01-01 00:00:00")) == datetime(2008, 1, 3) - def testRollback1(self, d, _offset): - assert _offset(10).rollback(d) == d + def testRollback1(self, dt, _offset): + assert _offset(10).rollback(dt) == dt def testRollback2(self, _offset): assert _offset(10).rollback(datetime(2008, 1, 5)) == datetime(2008, 1, 4) - def testRollforward1(self, d, _offset): - assert _offset(10).rollforward(d) == d + def testRollforward1(self, dt, _offset): + assert _offset(10).rollforward(dt) == dt def testRollforward2(self, _offset): assert _offset(10).rollforward(datetime(2008, 1, 5)) == datetime(2008, 1, 7) diff --git a/pandas/tests/tseries/offsets/test_business_hour.py b/pandas/tests/tseries/offsets/test_business_hour.py index 381d538fca5c0..cfd86d2098172 100644 --- a/pandas/tests/tseries/offsets/test_business_hour.py +++ b/pandas/tests/tseries/offsets/test_business_hour.py @@ -29,7 +29,7 @@ @pytest.fixture -def d(): +def dt(): return datetime(2014, 7, 1, 10, 00) @@ -160,11 +160,11 @@ def test_repr( assert repr(offset9) == "<3 * BusinessHours: BH=09:00-13:00,22:00-03:00>" assert repr(offset10) == "<-1 * BusinessHour: BH=13:00-17:00,23:00-02:00>" - def test_with_offset(self, d): + def test_with_offset(self, dt): expected = Timestamp("2014-07-01 13:00") - assert d + BusinessHour() * 3 == expected - assert d + BusinessHour(n=3) == expected + assert dt + BusinessHour() * 3 == expected + assert dt + BusinessHour(n=3) == expected @pytest.mark.parametrize( "offset_name", @@ -215,7 +215,7 @@ def test_hash(self, offset_name, request): def test_call( self, - d, + dt, offset1, offset2, offset3, @@ -229,26 +229,26 @@ def test_call( ): with tm.assert_produces_warning(FutureWarning): # GH#34171 DateOffset.__call__ is deprecated - assert offset1(d) == datetime(2014, 7, 1, 11) - assert offset2(d) == datetime(2014, 7, 1, 13) - assert offset3(d) == datetime(2014, 6, 30, 17) - assert offset4(d) == datetime(2014, 6, 30, 14) - assert offset8(d) == datetime(2014, 7, 1, 11) - assert offset9(d) == datetime(2014, 7, 1, 22) - assert offset10(d) == datetime(2014, 7, 1, 1) - - def test_sub(self, d, offset2, _offset): + assert offset1(dt) == datetime(2014, 7, 1, 11) + assert offset2(dt) == datetime(2014, 7, 1, 13) + assert offset3(dt) == datetime(2014, 6, 30, 17) + assert offset4(dt) == datetime(2014, 6, 30, 14) + assert offset8(dt) == datetime(2014, 7, 1, 11) + assert offset9(dt) == datetime(2014, 7, 1, 22) + assert offset10(dt) == datetime(2014, 7, 1, 1) + + def test_sub(self, dt, offset2, _offset): off = offset2 msg = "Cannot subtract datetime from offset" with pytest.raises(TypeError, match=msg): - off - d + off - dt assert 2 * off - off == off - assert d - offset2 == d + _offset(-3) + assert dt - offset2 == dt + _offset(-3) def testRollback1( self, - d, + dt, _offset, offset1, offset2, @@ -261,16 +261,16 @@ def testRollback1( offset9, offset10, ): - assert offset1.rollback(d) == d - assert offset2.rollback(d) == d - assert offset3.rollback(d) == d - assert offset4.rollback(d) == d - assert offset5.rollback(d) == datetime(2014, 6, 30, 14, 30) - assert offset6.rollback(d) == datetime(2014, 7, 1, 5, 0) - assert offset7.rollback(d) == datetime(2014, 7, 1, 6, 30) - assert offset8.rollback(d) == d - assert offset9.rollback(d) == d - assert offset10.rollback(d) == datetime(2014, 7, 1, 2) + assert offset1.rollback(dt) == dt + assert offset2.rollback(dt) == dt + assert offset3.rollback(dt) == dt + assert offset4.rollback(dt) == dt + assert offset5.rollback(dt) == datetime(2014, 6, 30, 14, 30) + assert offset6.rollback(dt) == datetime(2014, 7, 1, 5, 0) + assert offset7.rollback(dt) == datetime(2014, 7, 1, 6, 30) + assert offset8.rollback(dt) == dt + assert offset9.rollback(dt) == dt + assert offset10.rollback(dt) == datetime(2014, 7, 1, 2) datet = datetime(2014, 7, 1, 0) assert offset1.rollback(datet) == datetime(2014, 6, 30, 17) @@ -284,7 +284,7 @@ def testRollback1( assert offset9.rollback(datet) == datet assert offset10.rollback(datet) == datet - assert _offset(5).rollback(d) == d + assert _offset(5).rollback(dt) == dt def testRollback2(self, _offset): assert _offset(-3).rollback(datetime(2014, 7, 5, 15, 0)) == datetime( @@ -293,7 +293,7 @@ def testRollback2(self, _offset): def testRollforward1( self, - d, + dt, _offset, offset1, offset2, @@ -306,16 +306,16 @@ def testRollforward1( offset9, offset10, ): - assert offset1.rollforward(d) == d - assert offset2.rollforward(d) == d - assert offset3.rollforward(d) == d - assert offset4.rollforward(d) == d - assert offset5.rollforward(d) == datetime(2014, 7, 1, 11, 0) - assert offset6.rollforward(d) == datetime(2014, 7, 1, 20, 0) - assert offset7.rollforward(d) == datetime(2014, 7, 1, 21, 30) - assert offset8.rollforward(d) == d - assert offset9.rollforward(d) == d - assert offset10.rollforward(d) == datetime(2014, 7, 1, 13) + assert offset1.rollforward(dt) == dt + assert offset2.rollforward(dt) == dt + assert offset3.rollforward(dt) == dt + assert offset4.rollforward(dt) == dt + assert offset5.rollforward(dt) == datetime(2014, 7, 1, 11, 0) + assert offset6.rollforward(dt) == datetime(2014, 7, 1, 20, 0) + assert offset7.rollforward(dt) == datetime(2014, 7, 1, 21, 30) + assert offset8.rollforward(dt) == dt + assert offset9.rollforward(dt) == dt + assert offset10.rollforward(dt) == datetime(2014, 7, 1, 13) datet = datetime(2014, 7, 1, 0) assert offset1.rollforward(datet) == datetime(2014, 7, 1, 9) @@ -329,7 +329,7 @@ def testRollforward1( assert offset9.rollforward(datet) == datet assert offset10.rollforward(datet) == datet - assert _offset(5).rollforward(d) == d + assert _offset(5).rollforward(dt) == dt def testRollforward2(self, _offset): assert _offset(-3).rollforward(datetime(2014, 7, 5, 16, 0)) == datetime( diff --git a/pandas/tests/tseries/offsets/test_common.py b/pandas/tests/tseries/offsets/test_common.py index 1c140d7dda330..ca5feceabb411 100644 --- a/pandas/tests/tseries/offsets/test_common.py +++ b/pandas/tests/tseries/offsets/test_common.py @@ -104,7 +104,7 @@ def _offset(request): @pytest.fixture -def d(_offset): +def dt(_offset): if _offset in (CBMonthBegin, CBMonthEnd, BDay): return Timestamp(2008, 1, 1) elif _offset is (CustomBusinessHour, BusinessHour): @@ -237,9 +237,9 @@ def test_sub(date, offset_box, offset2): [BusinessHour, BusinessHour()], ], ) -def test_Mult1(offset_box, offset1, d): - assert d + 10 * offset1 == d + offset_box(10) - assert d + 5 * offset1 == d + offset_box(5) +def test_Mult1(offset_box, offset1, dt): + assert dt + 10 * offset1 == dt + offset_box(10) + assert dt + 5 * offset1 == dt + offset_box(5) def test_compare_str(_offset): diff --git a/pandas/tests/tseries/offsets/test_custom_business_hour.py b/pandas/tests/tseries/offsets/test_custom_business_hour.py index 56c4d248a278c..203a860998722 100644 --- a/pandas/tests/tseries/offsets/test_custom_business_hour.py +++ b/pandas/tests/tseries/offsets/test_custom_business_hour.py @@ -27,7 +27,7 @@ @pytest.fixture -def d(): +def dt(): return datetime(2014, 7, 1, 10, 00) @@ -73,11 +73,11 @@ def test_repr(self, offset1, offset2): assert repr(offset1) == "" assert repr(offset2) == "" - def test_with_offset(self, d): + def test_with_offset(self, dt): expected = Timestamp("2014-07-01 13:00") - assert d + CustomBusinessHour() * 3 == expected - assert d + CustomBusinessHour(n=3) == expected + assert dt + CustomBusinessHour() * 3 == expected + assert dt + CustomBusinessHour(n=3) == expected def test_eq(self, offset1, offset2): for offset in [offset1, offset2]: @@ -101,15 +101,15 @@ def test_hash(self, offset1, offset2): assert hash(offset1) == hash(offset1) assert hash(offset2) == hash(offset2) - def test_call(self, d, offset1, offset2): + def test_call(self, dt, offset1, offset2): with tm.assert_produces_warning(FutureWarning): # GH#34171 DateOffset.__call__ is deprecated - assert offset1(d) == datetime(2014, 7, 1, 11) - assert offset2(d) == datetime(2014, 7, 1, 11) + assert offset1(dt) == datetime(2014, 7, 1, 11) + assert offset2(dt) == datetime(2014, 7, 1, 11) - def testRollback1(self, d, offset1, offset2): - assert offset1.rollback(d) == d - assert offset2.rollback(d) == d + def testRollback1(self, dt, offset1, offset2): + assert offset1.rollback(dt) == dt + assert offset2.rollback(dt) == dt d = datetime(2014, 7, 1, 0) @@ -124,9 +124,9 @@ def testRollback2(self, _offset): 2014, 7, 4, 17, 0 ) - def testRollforward1(self, d, offset1, offset2): - assert offset1.rollforward(d) == d - assert offset2.rollforward(d) == d + def testRollforward1(self, dt, offset1, offset2): + assert offset1.rollforward(dt) == dt + assert offset2.rollforward(dt) == dt d = datetime(2014, 7, 1, 0) assert offset1.rollforward(d) == datetime(2014, 7, 1, 9) diff --git a/pandas/tests/tseries/offsets/test_custom_business_month.py b/pandas/tests/tseries/offsets/test_custom_business_month.py index 9c16ce1d7dd65..e70eddcc71d4c 100644 --- a/pandas/tests/tseries/offsets/test_custom_business_month.py +++ b/pandas/tests/tseries/offsets/test_custom_business_month.py @@ -36,7 +36,7 @@ @pytest.fixture -def d(): +def dt(): return datetime(2008, 1, 1) @@ -89,19 +89,19 @@ def test_repr(self, offset, offset2): assert repr(offset) == "" assert repr(offset2) == "<2 * CustomBusinessMonthBegins>" - def test_call(self, d, offset2): + def test_call(self, dt, offset2): with tm.assert_produces_warning(FutureWarning): # GH#34171 DateOffset.__call__ is deprecated - assert offset2(d) == datetime(2008, 3, 3) + assert offset2(dt) == datetime(2008, 3, 3) def testRollback1(self): assert CDay(10).rollback(datetime(2007, 12, 31)) == datetime(2007, 12, 31) - def testRollback2(self, d): - assert CBMonthBegin(10).rollback(d) == datetime(2008, 1, 1) + def testRollback2(self, dt): + assert CBMonthBegin(10).rollback(dt) == datetime(2008, 1, 1) - def testRollforward1(self, d): - assert CBMonthBegin(10).rollforward(d) == datetime(2008, 1, 1) + def testRollforward1(self, dt): + assert CBMonthBegin(10).rollforward(dt) == datetime(2008, 1, 1) def test_roll_date_object(self): offset = CBMonthBegin() @@ -289,19 +289,19 @@ def test_repr(self, offset, offset2): assert repr(offset) == "" assert repr(offset2) == "<2 * CustomBusinessMonthEnds>" - def test_call(self, d, offset2): + def test_call(self, dt, offset2): with tm.assert_produces_warning(FutureWarning): # GH#34171 DateOffset.__call__ is deprecated - assert offset2(d) == datetime(2008, 2, 29) + assert offset2(dt) == datetime(2008, 2, 29) def testRollback1(self): assert CDay(10).rollback(datetime(2007, 12, 31)) == datetime(2007, 12, 31) - def testRollback2(self, d): - assert CBMonthEnd(10).rollback(d) == datetime(2007, 12, 31) + def testRollback2(self, dt): + assert CBMonthEnd(10).rollback(dt) == datetime(2007, 12, 31) - def testRollforward1(self, d): - assert CBMonthEnd(10).rollforward(d) == datetime(2008, 1, 31) + def testRollforward1(self, dt): + assert CBMonthEnd(10).rollforward(dt) == datetime(2008, 1, 31) def test_roll_date_object(self): offset = CBMonthEnd() @@ -328,8 +328,8 @@ def test_roll_date_object(self): @pytest.mark.parametrize("case", on_offset_cases) def test_is_on_offset(self, case): - offset, d, expected = case - assert_is_on_offset(offset, d, expected) + offset, dt, expected = case + assert_is_on_offset(offset, dt, expected) apply_cases: _ApplyCases = [ ( diff --git a/pandas/tests/tseries/offsets/test_offsets.py b/pandas/tests/tseries/offsets/test_offsets.py index 6fd8a2ba1bdc6..ef45e354787ce 100644 --- a/pandas/tests/tseries/offsets/test_offsets.py +++ b/pandas/tests/tseries/offsets/test_offsets.py @@ -110,7 +110,7 @@ def _create_offset(klass, value=1, normalize=False): @pytest.fixture -def d(): +def dt(): return Timestamp(datetime(2008, 1, 2)) @@ -658,8 +658,8 @@ def test_constructor(self, kwd, request): assert offset.kwds == {kwd: 2} assert getattr(offset, kwd) == 2 - def test_default_constructor(self, d): - assert (d + DateOffset(2)) == datetime(2008, 1, 4) + def test_default_constructor(self, dt): + assert (dt + DateOffset(2)) == datetime(2008, 1, 4) def test_is_anchored(self): assert not DateOffset(2).is_anchored() @@ -686,9 +686,9 @@ def test_copy(self): ], ), ) - def test_add(self, arithmatic_offset_type, expected, d): - assert DateOffset(**{arithmatic_offset_type: 1}) + d == Timestamp(expected) - assert d + DateOffset(**{arithmatic_offset_type: 1}) == Timestamp(expected) + def test_add(self, arithmatic_offset_type, expected, dt): + assert DateOffset(**{arithmatic_offset_type: 1}) + dt == Timestamp(expected) + assert dt + DateOffset(**{arithmatic_offset_type: 1}) == Timestamp(expected) @pytest.mark.parametrize( "arithmatic_offset_type, expected", @@ -707,10 +707,10 @@ def test_add(self, arithmatic_offset_type, expected, d): ], ), ) - def test_sub(self, arithmatic_offset_type, expected, d): - assert d - DateOffset(**{arithmatic_offset_type: 1}) == Timestamp(expected) + def test_sub(self, arithmatic_offset_type, expected, dt): + assert dt - DateOffset(**{arithmatic_offset_type: 1}) == Timestamp(expected) with pytest.raises(TypeError, match="Cannot subtract datetime from offset"): - DateOffset(**{arithmatic_offset_type: 1}) - d + DateOffset(**{arithmatic_offset_type: 1}) - dt @pytest.mark.parametrize( "arithmatic_offset_type, n, expected", @@ -730,11 +730,11 @@ def test_sub(self, arithmatic_offset_type, expected, d): ], ), ) - def test_mul_add(self, arithmatic_offset_type, n, expected, d): - assert DateOffset(**{arithmatic_offset_type: 1}) * n + d == Timestamp(expected) - assert n * DateOffset(**{arithmatic_offset_type: 1}) + d == Timestamp(expected) - assert d + DateOffset(**{arithmatic_offset_type: 1}) * n == Timestamp(expected) - assert d + n * DateOffset(**{arithmatic_offset_type: 1}) == Timestamp(expected) + def test_mul_add(self, arithmatic_offset_type, n, expected, dt): + assert DateOffset(**{arithmatic_offset_type: 1}) * n + dt == Timestamp(expected) + assert n * DateOffset(**{arithmatic_offset_type: 1}) + dt == Timestamp(expected) + assert dt + DateOffset(**{arithmatic_offset_type: 1}) * n == Timestamp(expected) + assert dt + n * DateOffset(**{arithmatic_offset_type: 1}) == Timestamp(expected) @pytest.mark.parametrize( "arithmatic_offset_type, n, expected", @@ -754,9 +754,9 @@ def test_mul_add(self, arithmatic_offset_type, n, expected, d): ], ), ) - def test_mul_sub(self, arithmatic_offset_type, n, expected, d): - assert d - DateOffset(**{arithmatic_offset_type: 1}) * n == Timestamp(expected) - assert d - n * DateOffset(**{arithmatic_offset_type: 1}) == Timestamp(expected) + def test_mul_sub(self, arithmatic_offset_type, n, expected, dt): + assert dt - DateOffset(**{arithmatic_offset_type: 1}) * n == Timestamp(expected) + assert dt - n * DateOffset(**{arithmatic_offset_type: 1}) == Timestamp(expected) def test_leap_year(self): d = datetime(2008, 1, 31)