virtuelle Umgebung teil20b
This commit is contained in:
		
										
											Binary file not shown.
										
									
								
							
										
											Binary file not shown.
										
									
								
							
										
											Binary file not shown.
										
									
								
							
										
											Binary file not shown.
										
									
								
							
										
											Binary file not shown.
										
									
								
							@@ -0,0 +1,116 @@
 | 
			
		||||
from datetime import datetime
 | 
			
		||||
 | 
			
		||||
import pytest
 | 
			
		||||
 | 
			
		||||
from pandas import (
 | 
			
		||||
    DatetimeIndex,
 | 
			
		||||
    offsets,
 | 
			
		||||
    to_datetime,
 | 
			
		||||
)
 | 
			
		||||
import pandas._testing as tm
 | 
			
		||||
 | 
			
		||||
from pandas.tseries.holiday import (
 | 
			
		||||
    AbstractHolidayCalendar,
 | 
			
		||||
    Holiday,
 | 
			
		||||
    Timestamp,
 | 
			
		||||
    USFederalHolidayCalendar,
 | 
			
		||||
    USLaborDay,
 | 
			
		||||
    USThanksgivingDay,
 | 
			
		||||
    get_calendar,
 | 
			
		||||
)
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
@pytest.mark.parametrize(
 | 
			
		||||
    "transform", [lambda x: x, lambda x: x.strftime("%Y-%m-%d"), lambda x: Timestamp(x)]
 | 
			
		||||
)
 | 
			
		||||
def test_calendar(transform):
 | 
			
		||||
    start_date = datetime(2012, 1, 1)
 | 
			
		||||
    end_date = datetime(2012, 12, 31)
 | 
			
		||||
 | 
			
		||||
    calendar = USFederalHolidayCalendar()
 | 
			
		||||
    holidays = calendar.holidays(transform(start_date), transform(end_date))
 | 
			
		||||
 | 
			
		||||
    expected = [
 | 
			
		||||
        datetime(2012, 1, 2),
 | 
			
		||||
        datetime(2012, 1, 16),
 | 
			
		||||
        datetime(2012, 2, 20),
 | 
			
		||||
        datetime(2012, 5, 28),
 | 
			
		||||
        datetime(2012, 7, 4),
 | 
			
		||||
        datetime(2012, 9, 3),
 | 
			
		||||
        datetime(2012, 10, 8),
 | 
			
		||||
        datetime(2012, 11, 12),
 | 
			
		||||
        datetime(2012, 11, 22),
 | 
			
		||||
        datetime(2012, 12, 25),
 | 
			
		||||
    ]
 | 
			
		||||
 | 
			
		||||
    assert list(holidays.to_pydatetime()) == expected
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
def test_calendar_caching():
 | 
			
		||||
    # see gh-9552.
 | 
			
		||||
 | 
			
		||||
    class TestCalendar(AbstractHolidayCalendar):
 | 
			
		||||
        def __init__(self, name=None, rules=None) -> None:
 | 
			
		||||
            super().__init__(name=name, rules=rules)
 | 
			
		||||
 | 
			
		||||
    jan1 = TestCalendar(rules=[Holiday("jan1", year=2015, month=1, day=1)])
 | 
			
		||||
    jan2 = TestCalendar(rules=[Holiday("jan2", year=2015, month=1, day=2)])
 | 
			
		||||
 | 
			
		||||
    # Getting holidays for Jan 1 should not alter results for Jan 2.
 | 
			
		||||
    tm.assert_index_equal(jan1.holidays(), DatetimeIndex(["01-Jan-2015"]))
 | 
			
		||||
    tm.assert_index_equal(jan2.holidays(), DatetimeIndex(["02-Jan-2015"]))
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
def test_calendar_observance_dates():
 | 
			
		||||
    # see gh-11477
 | 
			
		||||
    us_fed_cal = get_calendar("USFederalHolidayCalendar")
 | 
			
		||||
    holidays0 = us_fed_cal.holidays(
 | 
			
		||||
        datetime(2015, 7, 3), datetime(2015, 7, 3)
 | 
			
		||||
    )  # <-- same start and end dates
 | 
			
		||||
    holidays1 = us_fed_cal.holidays(
 | 
			
		||||
        datetime(2015, 7, 3), datetime(2015, 7, 6)
 | 
			
		||||
    )  # <-- different start and end dates
 | 
			
		||||
    holidays2 = us_fed_cal.holidays(
 | 
			
		||||
        datetime(2015, 7, 3), datetime(2015, 7, 3)
 | 
			
		||||
    )  # <-- same start and end dates
 | 
			
		||||
 | 
			
		||||
    # These should all produce the same result.
 | 
			
		||||
    #
 | 
			
		||||
    # In addition, calling with different start and end
 | 
			
		||||
    # dates should not alter the output if we call the
 | 
			
		||||
    # function again with the same start and end date.
 | 
			
		||||
    tm.assert_index_equal(holidays0, holidays1)
 | 
			
		||||
    tm.assert_index_equal(holidays0, holidays2)
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
def test_rule_from_name():
 | 
			
		||||
    us_fed_cal = get_calendar("USFederalHolidayCalendar")
 | 
			
		||||
    assert us_fed_cal.rule_from_name("Thanksgiving Day") == USThanksgivingDay
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
def test_calendar_2031():
 | 
			
		||||
    # See gh-27790
 | 
			
		||||
    #
 | 
			
		||||
    # Labor Day 2031 is on September 1. Saturday before is August 30.
 | 
			
		||||
    # Next working day after August 30 ought to be Tuesday, September 2.
 | 
			
		||||
 | 
			
		||||
    class testCalendar(AbstractHolidayCalendar):
 | 
			
		||||
        rules = [USLaborDay]
 | 
			
		||||
 | 
			
		||||
    cal = testCalendar()
 | 
			
		||||
    workDay = offsets.CustomBusinessDay(calendar=cal)
 | 
			
		||||
    Sat_before_Labor_Day_2031 = to_datetime("2031-08-30")
 | 
			
		||||
    next_working_day = Sat_before_Labor_Day_2031 + 0 * workDay
 | 
			
		||||
    assert next_working_day == to_datetime("2031-09-02")
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
def test_no_holidays_calendar():
 | 
			
		||||
    # Test for issue #31415
 | 
			
		||||
 | 
			
		||||
    class NoHolidaysCalendar(AbstractHolidayCalendar):
 | 
			
		||||
        pass
 | 
			
		||||
 | 
			
		||||
    cal = NoHolidaysCalendar()
 | 
			
		||||
    holidays = cal.holidays(Timestamp("01-Jan-2020"), Timestamp("01-Jan-2021"))
 | 
			
		||||
    empty_index = DatetimeIndex([])  # Type is DatetimeIndex since return_name=False
 | 
			
		||||
    tm.assert_index_equal(holidays, empty_index)
 | 
			
		||||
@@ -0,0 +1,58 @@
 | 
			
		||||
from datetime import datetime
 | 
			
		||||
 | 
			
		||||
from pandas import DatetimeIndex
 | 
			
		||||
import pandas._testing as tm
 | 
			
		||||
 | 
			
		||||
from pandas.tseries.holiday import (
 | 
			
		||||
    AbstractHolidayCalendar,
 | 
			
		||||
    USFederalHolidayCalendar,
 | 
			
		||||
    USMartinLutherKingJr,
 | 
			
		||||
    USMemorialDay,
 | 
			
		||||
)
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
def test_no_mlk_before_1986():
 | 
			
		||||
    # see gh-10278
 | 
			
		||||
    class MLKCalendar(AbstractHolidayCalendar):
 | 
			
		||||
        rules = [USMartinLutherKingJr]
 | 
			
		||||
 | 
			
		||||
    holidays = MLKCalendar().holidays(start="1984", end="1988").to_pydatetime().tolist()
 | 
			
		||||
 | 
			
		||||
    # Testing to make sure holiday is not incorrectly observed before 1986.
 | 
			
		||||
    assert holidays == [datetime(1986, 1, 20, 0, 0), datetime(1987, 1, 19, 0, 0)]
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
def test_memorial_day():
 | 
			
		||||
    class MemorialDay(AbstractHolidayCalendar):
 | 
			
		||||
        rules = [USMemorialDay]
 | 
			
		||||
 | 
			
		||||
    holidays = MemorialDay().holidays(start="1971", end="1980").to_pydatetime().tolist()
 | 
			
		||||
 | 
			
		||||
    # Fixes 5/31 error and checked manually against Wikipedia.
 | 
			
		||||
    assert holidays == [
 | 
			
		||||
        datetime(1971, 5, 31, 0, 0),
 | 
			
		||||
        datetime(1972, 5, 29, 0, 0),
 | 
			
		||||
        datetime(1973, 5, 28, 0, 0),
 | 
			
		||||
        datetime(1974, 5, 27, 0, 0),
 | 
			
		||||
        datetime(1975, 5, 26, 0, 0),
 | 
			
		||||
        datetime(1976, 5, 31, 0, 0),
 | 
			
		||||
        datetime(1977, 5, 30, 0, 0),
 | 
			
		||||
        datetime(1978, 5, 29, 0, 0),
 | 
			
		||||
        datetime(1979, 5, 28, 0, 0),
 | 
			
		||||
    ]
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
def test_federal_holiday_inconsistent_returntype():
 | 
			
		||||
    # GH 49075 test case
 | 
			
		||||
    # Instantiate two calendars to rule out _cache
 | 
			
		||||
    cal1 = USFederalHolidayCalendar()
 | 
			
		||||
    cal2 = USFederalHolidayCalendar()
 | 
			
		||||
 | 
			
		||||
    results_2018 = cal1.holidays(start=datetime(2018, 8, 1), end=datetime(2018, 8, 31))
 | 
			
		||||
    results_2019 = cal2.holidays(start=datetime(2019, 8, 1), end=datetime(2019, 8, 31))
 | 
			
		||||
    expected_results = DatetimeIndex([], dtype="datetime64[ns]", freq=None)
 | 
			
		||||
 | 
			
		||||
    # Check against expected results to ensure both date
 | 
			
		||||
    # ranges generate expected results as per GH49075 submission
 | 
			
		||||
    tm.assert_index_equal(results_2018, expected_results)
 | 
			
		||||
    tm.assert_index_equal(results_2019, expected_results)
 | 
			
		||||
@@ -0,0 +1,313 @@
 | 
			
		||||
from datetime import datetime
 | 
			
		||||
 | 
			
		||||
import pytest
 | 
			
		||||
from pytz import utc
 | 
			
		||||
 | 
			
		||||
from pandas import DatetimeIndex
 | 
			
		||||
import pandas._testing as tm
 | 
			
		||||
 | 
			
		||||
from pandas.tseries.holiday import (
 | 
			
		||||
    MO,
 | 
			
		||||
    SA,
 | 
			
		||||
    AbstractHolidayCalendar,
 | 
			
		||||
    DateOffset,
 | 
			
		||||
    EasterMonday,
 | 
			
		||||
    GoodFriday,
 | 
			
		||||
    Holiday,
 | 
			
		||||
    HolidayCalendarFactory,
 | 
			
		||||
    Timestamp,
 | 
			
		||||
    USColumbusDay,
 | 
			
		||||
    USLaborDay,
 | 
			
		||||
    USMartinLutherKingJr,
 | 
			
		||||
    USMemorialDay,
 | 
			
		||||
    USPresidentsDay,
 | 
			
		||||
    USThanksgivingDay,
 | 
			
		||||
    get_calendar,
 | 
			
		||||
    next_monday,
 | 
			
		||||
)
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
@pytest.mark.parametrize(
 | 
			
		||||
    "holiday,start_date,end_date,expected",
 | 
			
		||||
    [
 | 
			
		||||
        (
 | 
			
		||||
            USMemorialDay,
 | 
			
		||||
            datetime(2011, 1, 1),
 | 
			
		||||
            datetime(2020, 12, 31),
 | 
			
		||||
            [
 | 
			
		||||
                datetime(2011, 5, 30),
 | 
			
		||||
                datetime(2012, 5, 28),
 | 
			
		||||
                datetime(2013, 5, 27),
 | 
			
		||||
                datetime(2014, 5, 26),
 | 
			
		||||
                datetime(2015, 5, 25),
 | 
			
		||||
                datetime(2016, 5, 30),
 | 
			
		||||
                datetime(2017, 5, 29),
 | 
			
		||||
                datetime(2018, 5, 28),
 | 
			
		||||
                datetime(2019, 5, 27),
 | 
			
		||||
                datetime(2020, 5, 25),
 | 
			
		||||
            ],
 | 
			
		||||
        ),
 | 
			
		||||
        (
 | 
			
		||||
            Holiday("July 4th Eve", month=7, day=3),
 | 
			
		||||
            "2001-01-01",
 | 
			
		||||
            "2003-03-03",
 | 
			
		||||
            [Timestamp("2001-07-03 00:00:00"), Timestamp("2002-07-03 00:00:00")],
 | 
			
		||||
        ),
 | 
			
		||||
        (
 | 
			
		||||
            Holiday("July 4th Eve", month=7, day=3, days_of_week=(0, 1, 2, 3)),
 | 
			
		||||
            "2001-01-01",
 | 
			
		||||
            "2008-03-03",
 | 
			
		||||
            [
 | 
			
		||||
                Timestamp("2001-07-03 00:00:00"),
 | 
			
		||||
                Timestamp("2002-07-03 00:00:00"),
 | 
			
		||||
                Timestamp("2003-07-03 00:00:00"),
 | 
			
		||||
                Timestamp("2006-07-03 00:00:00"),
 | 
			
		||||
                Timestamp("2007-07-03 00:00:00"),
 | 
			
		||||
            ],
 | 
			
		||||
        ),
 | 
			
		||||
        (
 | 
			
		||||
            EasterMonday,
 | 
			
		||||
            datetime(2011, 1, 1),
 | 
			
		||||
            datetime(2020, 12, 31),
 | 
			
		||||
            [
 | 
			
		||||
                Timestamp("2011-04-25 00:00:00"),
 | 
			
		||||
                Timestamp("2012-04-09 00:00:00"),
 | 
			
		||||
                Timestamp("2013-04-01 00:00:00"),
 | 
			
		||||
                Timestamp("2014-04-21 00:00:00"),
 | 
			
		||||
                Timestamp("2015-04-06 00:00:00"),
 | 
			
		||||
                Timestamp("2016-03-28 00:00:00"),
 | 
			
		||||
                Timestamp("2017-04-17 00:00:00"),
 | 
			
		||||
                Timestamp("2018-04-02 00:00:00"),
 | 
			
		||||
                Timestamp("2019-04-22 00:00:00"),
 | 
			
		||||
                Timestamp("2020-04-13 00:00:00"),
 | 
			
		||||
            ],
 | 
			
		||||
        ),
 | 
			
		||||
        (
 | 
			
		||||
            GoodFriday,
 | 
			
		||||
            datetime(2011, 1, 1),
 | 
			
		||||
            datetime(2020, 12, 31),
 | 
			
		||||
            [
 | 
			
		||||
                Timestamp("2011-04-22 00:00:00"),
 | 
			
		||||
                Timestamp("2012-04-06 00:00:00"),
 | 
			
		||||
                Timestamp("2013-03-29 00:00:00"),
 | 
			
		||||
                Timestamp("2014-04-18 00:00:00"),
 | 
			
		||||
                Timestamp("2015-04-03 00:00:00"),
 | 
			
		||||
                Timestamp("2016-03-25 00:00:00"),
 | 
			
		||||
                Timestamp("2017-04-14 00:00:00"),
 | 
			
		||||
                Timestamp("2018-03-30 00:00:00"),
 | 
			
		||||
                Timestamp("2019-04-19 00:00:00"),
 | 
			
		||||
                Timestamp("2020-04-10 00:00:00"),
 | 
			
		||||
            ],
 | 
			
		||||
        ),
 | 
			
		||||
        (
 | 
			
		||||
            USThanksgivingDay,
 | 
			
		||||
            datetime(2011, 1, 1),
 | 
			
		||||
            datetime(2020, 12, 31),
 | 
			
		||||
            [
 | 
			
		||||
                datetime(2011, 11, 24),
 | 
			
		||||
                datetime(2012, 11, 22),
 | 
			
		||||
                datetime(2013, 11, 28),
 | 
			
		||||
                datetime(2014, 11, 27),
 | 
			
		||||
                datetime(2015, 11, 26),
 | 
			
		||||
                datetime(2016, 11, 24),
 | 
			
		||||
                datetime(2017, 11, 23),
 | 
			
		||||
                datetime(2018, 11, 22),
 | 
			
		||||
                datetime(2019, 11, 28),
 | 
			
		||||
                datetime(2020, 11, 26),
 | 
			
		||||
            ],
 | 
			
		||||
        ),
 | 
			
		||||
    ],
 | 
			
		||||
)
 | 
			
		||||
def test_holiday_dates(holiday, start_date, end_date, expected):
 | 
			
		||||
    assert list(holiday.dates(start_date, end_date)) == expected
 | 
			
		||||
 | 
			
		||||
    # Verify that timezone info is preserved.
 | 
			
		||||
    assert list(
 | 
			
		||||
        holiday.dates(
 | 
			
		||||
            utc.localize(Timestamp(start_date)), utc.localize(Timestamp(end_date))
 | 
			
		||||
        )
 | 
			
		||||
    ) == [utc.localize(dt) for dt in expected]
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
@pytest.mark.parametrize(
 | 
			
		||||
    "holiday,start,expected",
 | 
			
		||||
    [
 | 
			
		||||
        (USMemorialDay, datetime(2015, 7, 1), []),
 | 
			
		||||
        (USMemorialDay, "2015-05-25", [Timestamp("2015-05-25")]),
 | 
			
		||||
        (USLaborDay, datetime(2015, 7, 1), []),
 | 
			
		||||
        (USLaborDay, "2015-09-07", [Timestamp("2015-09-07")]),
 | 
			
		||||
        (USColumbusDay, datetime(2015, 7, 1), []),
 | 
			
		||||
        (USColumbusDay, "2015-10-12", [Timestamp("2015-10-12")]),
 | 
			
		||||
        (USThanksgivingDay, datetime(2015, 7, 1), []),
 | 
			
		||||
        (USThanksgivingDay, "2015-11-26", [Timestamp("2015-11-26")]),
 | 
			
		||||
        (USMartinLutherKingJr, datetime(2015, 7, 1), []),
 | 
			
		||||
        (USMartinLutherKingJr, "2015-01-19", [Timestamp("2015-01-19")]),
 | 
			
		||||
        (USPresidentsDay, datetime(2015, 7, 1), []),
 | 
			
		||||
        (USPresidentsDay, "2015-02-16", [Timestamp("2015-02-16")]),
 | 
			
		||||
        (GoodFriday, datetime(2015, 7, 1), []),
 | 
			
		||||
        (GoodFriday, "2015-04-03", [Timestamp("2015-04-03")]),
 | 
			
		||||
        (EasterMonday, "2015-04-06", [Timestamp("2015-04-06")]),
 | 
			
		||||
        (EasterMonday, datetime(2015, 7, 1), []),
 | 
			
		||||
        (EasterMonday, "2015-04-05", []),
 | 
			
		||||
        ("New Year's Day", "2015-01-01", [Timestamp("2015-01-01")]),
 | 
			
		||||
        ("New Year's Day", "2010-12-31", [Timestamp("2010-12-31")]),
 | 
			
		||||
        ("New Year's Day", datetime(2015, 7, 1), []),
 | 
			
		||||
        ("New Year's Day", "2011-01-01", []),
 | 
			
		||||
        ("Independence Day", "2015-07-03", [Timestamp("2015-07-03")]),
 | 
			
		||||
        ("Independence Day", datetime(2015, 7, 1), []),
 | 
			
		||||
        ("Independence Day", "2015-07-04", []),
 | 
			
		||||
        ("Veterans Day", "2012-11-12", [Timestamp("2012-11-12")]),
 | 
			
		||||
        ("Veterans Day", datetime(2015, 7, 1), []),
 | 
			
		||||
        ("Veterans Day", "2012-11-11", []),
 | 
			
		||||
        ("Christmas Day", "2011-12-26", [Timestamp("2011-12-26")]),
 | 
			
		||||
        ("Christmas Day", datetime(2015, 7, 1), []),
 | 
			
		||||
        ("Christmas Day", "2011-12-25", []),
 | 
			
		||||
        ("Juneteenth National Independence Day", "2020-06-19", []),
 | 
			
		||||
        (
 | 
			
		||||
            "Juneteenth National Independence Day",
 | 
			
		||||
            "2021-06-18",
 | 
			
		||||
            [Timestamp("2021-06-18")],
 | 
			
		||||
        ),
 | 
			
		||||
        ("Juneteenth National Independence Day", "2022-06-19", []),
 | 
			
		||||
        (
 | 
			
		||||
            "Juneteenth National Independence Day",
 | 
			
		||||
            "2022-06-20",
 | 
			
		||||
            [Timestamp("2022-06-20")],
 | 
			
		||||
        ),
 | 
			
		||||
    ],
 | 
			
		||||
)
 | 
			
		||||
def test_holidays_within_dates(holiday, start, expected):
 | 
			
		||||
    # see gh-11477
 | 
			
		||||
    #
 | 
			
		||||
    # Fix holiday behavior where holiday.dates returned dates outside
 | 
			
		||||
    # start/end date, or observed rules could not be applied because the
 | 
			
		||||
    # holiday was not in the original date range (e.g., 7/4/2015 -> 7/3/2015).
 | 
			
		||||
    if isinstance(holiday, str):
 | 
			
		||||
        calendar = get_calendar("USFederalHolidayCalendar")
 | 
			
		||||
        holiday = calendar.rule_from_name(holiday)
 | 
			
		||||
 | 
			
		||||
    assert list(holiday.dates(start, start)) == expected
 | 
			
		||||
 | 
			
		||||
    # Verify that timezone info is preserved.
 | 
			
		||||
    assert list(
 | 
			
		||||
        holiday.dates(utc.localize(Timestamp(start)), utc.localize(Timestamp(start)))
 | 
			
		||||
    ) == [utc.localize(dt) for dt in expected]
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
@pytest.mark.parametrize(
 | 
			
		||||
    "transform", [lambda x: x.strftime("%Y-%m-%d"), lambda x: Timestamp(x)]
 | 
			
		||||
)
 | 
			
		||||
def test_argument_types(transform):
 | 
			
		||||
    start_date = datetime(2011, 1, 1)
 | 
			
		||||
    end_date = datetime(2020, 12, 31)
 | 
			
		||||
 | 
			
		||||
    holidays = USThanksgivingDay.dates(start_date, end_date)
 | 
			
		||||
    holidays2 = USThanksgivingDay.dates(transform(start_date), transform(end_date))
 | 
			
		||||
    tm.assert_index_equal(holidays, holidays2)
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
@pytest.mark.parametrize(
 | 
			
		||||
    "name,kwargs",
 | 
			
		||||
    [
 | 
			
		||||
        ("One-Time", {"year": 2012, "month": 5, "day": 28}),
 | 
			
		||||
        (
 | 
			
		||||
            "Range",
 | 
			
		||||
            {
 | 
			
		||||
                "month": 5,
 | 
			
		||||
                "day": 28,
 | 
			
		||||
                "start_date": datetime(2012, 1, 1),
 | 
			
		||||
                "end_date": datetime(2012, 12, 31),
 | 
			
		||||
                "offset": DateOffset(weekday=MO(1)),
 | 
			
		||||
            },
 | 
			
		||||
        ),
 | 
			
		||||
    ],
 | 
			
		||||
)
 | 
			
		||||
def test_special_holidays(name, kwargs):
 | 
			
		||||
    base_date = [datetime(2012, 5, 28)]
 | 
			
		||||
    holiday = Holiday(name, **kwargs)
 | 
			
		||||
 | 
			
		||||
    start_date = datetime(2011, 1, 1)
 | 
			
		||||
    end_date = datetime(2020, 12, 31)
 | 
			
		||||
 | 
			
		||||
    assert base_date == holiday.dates(start_date, end_date)
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
def test_get_calendar():
 | 
			
		||||
    class TestCalendar(AbstractHolidayCalendar):
 | 
			
		||||
        rules = []
 | 
			
		||||
 | 
			
		||||
    calendar = get_calendar("TestCalendar")
 | 
			
		||||
    assert TestCalendar == type(calendar)
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
def test_factory():
 | 
			
		||||
    class_1 = HolidayCalendarFactory(
 | 
			
		||||
        "MemorialDay", AbstractHolidayCalendar, USMemorialDay
 | 
			
		||||
    )
 | 
			
		||||
    class_2 = HolidayCalendarFactory(
 | 
			
		||||
        "Thanksgiving", AbstractHolidayCalendar, USThanksgivingDay
 | 
			
		||||
    )
 | 
			
		||||
    class_3 = HolidayCalendarFactory("Combined", class_1, class_2)
 | 
			
		||||
 | 
			
		||||
    assert len(class_1.rules) == 1
 | 
			
		||||
    assert len(class_2.rules) == 1
 | 
			
		||||
    assert len(class_3.rules) == 2
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
def test_both_offset_observance_raises():
 | 
			
		||||
    # see gh-10217
 | 
			
		||||
    msg = "Cannot use both offset and observance"
 | 
			
		||||
    with pytest.raises(NotImplementedError, match=msg):
 | 
			
		||||
        Holiday(
 | 
			
		||||
            "Cyber Monday",
 | 
			
		||||
            month=11,
 | 
			
		||||
            day=1,
 | 
			
		||||
            offset=[DateOffset(weekday=SA(4))],
 | 
			
		||||
            observance=next_monday,
 | 
			
		||||
        )
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
def test_half_open_interval_with_observance():
 | 
			
		||||
    # Prompted by GH 49075
 | 
			
		||||
    # Check for holidays that have a half-open date interval where
 | 
			
		||||
    # they have either a start_date or end_date defined along
 | 
			
		||||
    # with a defined observance pattern to make sure that the return type
 | 
			
		||||
    # for Holiday.dates() remains consistent before & after the year that
 | 
			
		||||
    # marks the 'edge' of the half-open date interval.
 | 
			
		||||
 | 
			
		||||
    holiday_1 = Holiday(
 | 
			
		||||
        "Arbitrary Holiday - start 2022-03-14",
 | 
			
		||||
        start_date=datetime(2022, 3, 14),
 | 
			
		||||
        month=3,
 | 
			
		||||
        day=14,
 | 
			
		||||
        observance=next_monday,
 | 
			
		||||
    )
 | 
			
		||||
    holiday_2 = Holiday(
 | 
			
		||||
        "Arbitrary Holiday 2 - end 2022-03-20",
 | 
			
		||||
        end_date=datetime(2022, 3, 20),
 | 
			
		||||
        month=3,
 | 
			
		||||
        day=20,
 | 
			
		||||
        observance=next_monday,
 | 
			
		||||
    )
 | 
			
		||||
 | 
			
		||||
    class TestHolidayCalendar(AbstractHolidayCalendar):
 | 
			
		||||
        rules = [
 | 
			
		||||
            USMartinLutherKingJr,
 | 
			
		||||
            holiday_1,
 | 
			
		||||
            holiday_2,
 | 
			
		||||
            USLaborDay,
 | 
			
		||||
        ]
 | 
			
		||||
 | 
			
		||||
    start = Timestamp("2022-08-01")
 | 
			
		||||
    end = Timestamp("2022-08-31")
 | 
			
		||||
    year_offset = DateOffset(years=5)
 | 
			
		||||
    expected_results = DatetimeIndex([], dtype="datetime64[ns]", freq=None)
 | 
			
		||||
    test_cal = TestHolidayCalendar()
 | 
			
		||||
 | 
			
		||||
    date_interval_low = test_cal.holidays(start - year_offset, end - year_offset)
 | 
			
		||||
    date_window_edge = test_cal.holidays(start, end)
 | 
			
		||||
    date_interval_high = test_cal.holidays(start + year_offset, end + year_offset)
 | 
			
		||||
 | 
			
		||||
    tm.assert_index_equal(date_interval_low, expected_results)
 | 
			
		||||
    tm.assert_index_equal(date_window_edge, expected_results)
 | 
			
		||||
    tm.assert_index_equal(date_interval_high, expected_results)
 | 
			
		||||
@@ -0,0 +1,105 @@
 | 
			
		||||
from datetime import datetime
 | 
			
		||||
 | 
			
		||||
import pytest
 | 
			
		||||
 | 
			
		||||
from pandas.tseries.holiday import (
 | 
			
		||||
    after_nearest_workday,
 | 
			
		||||
    before_nearest_workday,
 | 
			
		||||
    nearest_workday,
 | 
			
		||||
    next_monday,
 | 
			
		||||
    next_monday_or_tuesday,
 | 
			
		||||
    next_workday,
 | 
			
		||||
    previous_friday,
 | 
			
		||||
    previous_workday,
 | 
			
		||||
    sunday_to_monday,
 | 
			
		||||
    weekend_to_monday,
 | 
			
		||||
)
 | 
			
		||||
 | 
			
		||||
_WEDNESDAY = datetime(2014, 4, 9)
 | 
			
		||||
_THURSDAY = datetime(2014, 4, 10)
 | 
			
		||||
_FRIDAY = datetime(2014, 4, 11)
 | 
			
		||||
_SATURDAY = datetime(2014, 4, 12)
 | 
			
		||||
_SUNDAY = datetime(2014, 4, 13)
 | 
			
		||||
_MONDAY = datetime(2014, 4, 14)
 | 
			
		||||
_TUESDAY = datetime(2014, 4, 15)
 | 
			
		||||
_NEXT_WEDNESDAY = datetime(2014, 4, 16)
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
@pytest.mark.parametrize("day", [_SATURDAY, _SUNDAY])
 | 
			
		||||
def test_next_monday(day):
 | 
			
		||||
    assert next_monday(day) == _MONDAY
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
@pytest.mark.parametrize(
 | 
			
		||||
    "day,expected", [(_SATURDAY, _MONDAY), (_SUNDAY, _TUESDAY), (_MONDAY, _TUESDAY)]
 | 
			
		||||
)
 | 
			
		||||
def test_next_monday_or_tuesday(day, expected):
 | 
			
		||||
    assert next_monday_or_tuesday(day) == expected
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
@pytest.mark.parametrize("day", [_SATURDAY, _SUNDAY])
 | 
			
		||||
def test_previous_friday(day):
 | 
			
		||||
    assert previous_friday(day) == _FRIDAY
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
def test_sunday_to_monday():
 | 
			
		||||
    assert sunday_to_monday(_SUNDAY) == _MONDAY
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
@pytest.mark.parametrize(
 | 
			
		||||
    "day,expected", [(_SATURDAY, _FRIDAY), (_SUNDAY, _MONDAY), (_MONDAY, _MONDAY)]
 | 
			
		||||
)
 | 
			
		||||
def test_nearest_workday(day, expected):
 | 
			
		||||
    assert nearest_workday(day) == expected
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
@pytest.mark.parametrize(
 | 
			
		||||
    "day,expected", [(_SATURDAY, _MONDAY), (_SUNDAY, _MONDAY), (_MONDAY, _MONDAY)]
 | 
			
		||||
)
 | 
			
		||||
def test_weekend_to_monday(day, expected):
 | 
			
		||||
    assert weekend_to_monday(day) == expected
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
@pytest.mark.parametrize(
 | 
			
		||||
    "day,expected",
 | 
			
		||||
    [
 | 
			
		||||
        (_WEDNESDAY, _THURSDAY),
 | 
			
		||||
        (_THURSDAY, _FRIDAY),
 | 
			
		||||
        (_SATURDAY, _MONDAY),
 | 
			
		||||
        (_SUNDAY, _MONDAY),
 | 
			
		||||
        (_MONDAY, _TUESDAY),
 | 
			
		||||
        (_TUESDAY, _NEXT_WEDNESDAY),  # WED is same week as TUE
 | 
			
		||||
    ],
 | 
			
		||||
)
 | 
			
		||||
def test_next_workday(day, expected):
 | 
			
		||||
    assert next_workday(day) == expected
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
@pytest.mark.parametrize(
 | 
			
		||||
    "day,expected", [(_SATURDAY, _FRIDAY), (_SUNDAY, _FRIDAY), (_TUESDAY, _MONDAY)]
 | 
			
		||||
)
 | 
			
		||||
def test_previous_workday(day, expected):
 | 
			
		||||
    assert previous_workday(day) == expected
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
@pytest.mark.parametrize(
 | 
			
		||||
    "day,expected",
 | 
			
		||||
    [
 | 
			
		||||
        (_THURSDAY, _WEDNESDAY),
 | 
			
		||||
        (_FRIDAY, _THURSDAY),
 | 
			
		||||
        (_SATURDAY, _THURSDAY),
 | 
			
		||||
        (_SUNDAY, _FRIDAY),
 | 
			
		||||
        (_MONDAY, _FRIDAY),  # last week Friday
 | 
			
		||||
        (_TUESDAY, _MONDAY),
 | 
			
		||||
        (_NEXT_WEDNESDAY, _TUESDAY),  # WED is same week as TUE
 | 
			
		||||
    ],
 | 
			
		||||
)
 | 
			
		||||
def test_before_nearest_workday(day, expected):
 | 
			
		||||
    assert before_nearest_workday(day) == expected
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
@pytest.mark.parametrize(
 | 
			
		||||
    "day,expected", [(_SATURDAY, _MONDAY), (_SUNDAY, _TUESDAY), (_FRIDAY, _MONDAY)]
 | 
			
		||||
)
 | 
			
		||||
def test_after_nearest_workday(day, expected):
 | 
			
		||||
    assert after_nearest_workday(day) == expected
 | 
			
		||||
		Reference in New Issue
	
	Block a user