first commit

.venv/Lib/site-packages/pandas/tseries/__init__.py

@@ -0,0 +1,11 @@
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    # import modules that have public classes/functions:
+    from pandas.tseries import (
+        frequencies,
+        offsets,
+    )
+
+    # and mark only those modules as public
+    __all__ = ["frequencies", "offsets"]

.venv/Lib/site-packages/pandas/tseries/api.py

@@ -0,0 +1,8 @@
+"""
+Timeseries API
+"""
+
+# flake8: noqa:F401
+
+from pandas.tseries.frequencies import infer_freq
+import pandas.tseries.offsets as offsets

.venv/Lib/site-packages/pandas/tseries/frequencies.py

@@ -0,0 +1,613 @@
+from __future__ import annotations
+
+import warnings
+
+import numpy as np
+
+from pandas._libs.algos import unique_deltas
+from pandas._libs.tslibs import (
+    Timestamp,
+    tzconversion,
+)
+from pandas._libs.tslibs.ccalendar import (
+    DAYS,
+    MONTH_ALIASES,
+    MONTH_NUMBERS,
+    MONTHS,
+    int_to_weekday,
+)
+from pandas._libs.tslibs.fields import (
+    build_field_sarray,
+    month_position_check,
+)
+from pandas._libs.tslibs.offsets import (  # noqa:F401
+    DateOffset,
+    Day,
+    _get_offset,
+    to_offset,
+)
+from pandas._libs.tslibs.parsing import get_rule_month
+from pandas._typing import npt
+from pandas.util._decorators import cache_readonly
+from pandas.util._exceptions import find_stack_level
+
+from pandas.core.dtypes.common import (
+    is_datetime64_dtype,
+    is_period_dtype,
+    is_timedelta64_dtype,
+)
+from pandas.core.dtypes.generic import ABCSeries
+
+from pandas.core.algorithms import unique
+
+_ONE_MICRO = 1000
+_ONE_MILLI = _ONE_MICRO * 1000
+_ONE_SECOND = _ONE_MILLI * 1000
+_ONE_MINUTE = 60 * _ONE_SECOND
+_ONE_HOUR = 60 * _ONE_MINUTE
+_ONE_DAY = 24 * _ONE_HOUR
+
+# ---------------------------------------------------------------------
+# Offset names ("time rules") and related functions
+
+_offset_to_period_map = {
+    "WEEKDAY": "D",
+    "EOM": "M",
+    "BM": "M",
+    "BQS": "Q",
+    "QS": "Q",
+    "BQ": "Q",
+    "BA": "A",
+    "AS": "A",
+    "BAS": "A",
+    "MS": "M",
+    "D": "D",
+    "C": "C",
+    "B": "B",
+    "T": "T",
+    "S": "S",
+    "L": "L",
+    "U": "U",
+    "N": "N",
+    "H": "H",
+    "Q": "Q",
+    "A": "A",
+    "W": "W",
+    "M": "M",
+    "Y": "A",
+    "BY": "A",
+    "YS": "A",
+    "BYS": "A",
+}
+
+_need_suffix = ["QS", "BQ", "BQS", "YS", "AS", "BY", "BA", "BYS", "BAS"]
+
+for _prefix in _need_suffix:
+    for _m in MONTHS:
+        key = f"{_prefix}-{_m}"
+        _offset_to_period_map[key] = _offset_to_period_map[_prefix]
+
+for _prefix in ["A", "Q"]:
+    for _m in MONTHS:
+        _alias = f"{_prefix}-{_m}"
+        _offset_to_period_map[_alias] = _alias
+
+for _d in DAYS:
+    _offset_to_period_map[f"W-{_d}"] = f"W-{_d}"
+
+
+def get_period_alias(offset_str: str) -> str | None:
+    """
+    Alias to closest period strings BQ->Q etc.
+    """
+    return _offset_to_period_map.get(offset_str, None)
+
+
+def get_offset(name: str) -> DateOffset:
+    """
+    Return DateOffset object associated with rule name.
+
+    .. deprecated:: 1.0.0
+
+    Examples
+    --------
+    get_offset('EOM') --> BMonthEnd(1)
+    """
+    warnings.warn(
+        "get_offset is deprecated and will be removed in a future version, "
+        "use to_offset instead.",
+        FutureWarning,
+        stacklevel=find_stack_level(),
+    )
+    return _get_offset(name)
+
+
+# ---------------------------------------------------------------------
+# Period codes
+
+
+def infer_freq(index, warn: bool = True) -> str | None:
+    """
+    Infer the most likely frequency given the input index. If the frequency is
+    uncertain, a warning will be printed.
+
+    Parameters
+    ----------
+    index : DatetimeIndex or TimedeltaIndex
+      If passed a Series will use the values of the series (NOT THE INDEX).
+    warn : bool, default True
+
+    Returns
+    -------
+    str or None
+        None if no discernible frequency.
+
+    Raises
+    ------
+    TypeError
+        If the index is not datetime-like.
+    ValueError
+        If there are fewer than three values.
+
+    Examples
+    --------
+    >>> idx = pd.date_range(start='2020/12/01', end='2020/12/30', periods=30)
+    >>> pd.infer_freq(idx)
+    'D'
+    """
+    from pandas.core.api import (
+        DatetimeIndex,
+        Float64Index,
+        Index,
+        Int64Index,
+    )
+
+    if isinstance(index, ABCSeries):
+        values = index._values
+        if not (
+            is_datetime64_dtype(values)
+            or is_timedelta64_dtype(values)
+            or values.dtype == object
+        ):
+            raise TypeError(
+                "cannot infer freq from a non-convertible dtype "
+                f"on a Series of {index.dtype}"
+            )
+        index = values
+
+    inferer: _FrequencyInferer
+
+    if not hasattr(index, "dtype"):
+        pass
+    elif is_period_dtype(index.dtype):
+        raise TypeError(
+            "PeriodIndex given. Check the `freq` attribute "
+            "instead of using infer_freq."
+        )
+    elif is_timedelta64_dtype(index.dtype):
+        # Allow TimedeltaIndex and TimedeltaArray
+        inferer = _TimedeltaFrequencyInferer(index, warn=warn)
+        return inferer.get_freq()
+
+    if isinstance(index, Index) and not isinstance(index, DatetimeIndex):
+        if isinstance(index, (Int64Index, Float64Index)):
+            raise TypeError(
+                f"cannot infer freq from a non-convertible index type {type(index)}"
+            )
+        index = index._values
+
+    if not isinstance(index, DatetimeIndex):
+        index = DatetimeIndex(index)
+
+    inferer = _FrequencyInferer(index, warn=warn)
+    return inferer.get_freq()
+
+
+class _FrequencyInferer:
+    """
+    Not sure if I can avoid the state machine here
+    """
+
+    def __init__(self, index, warn: bool = True):
+        self.index = index
+        self.i8values = index.asi8
+
+        # This moves the values, which are implicitly in UTC, to the
+        # the timezone so they are in local time
+        if hasattr(index, "tz"):
+            if index.tz is not None:
+                self.i8values = tzconversion.tz_convert_from_utc(
+                    self.i8values, index.tz
+                )
+
+        self.warn = warn
+
+        if len(index) < 3:
+            raise ValueError("Need at least 3 dates to infer frequency")
+
+        self.is_monotonic = (
+            self.index._is_monotonic_increasing or self.index._is_monotonic_decreasing
+        )
+
+    @cache_readonly
+    def deltas(self) -> npt.NDArray[np.int64]:
+        return unique_deltas(self.i8values)
+
+    @cache_readonly
+    def deltas_asi8(self) -> npt.NDArray[np.int64]:
+        # NB: we cannot use self.i8values here because we may have converted
+        #  the tz in __init__
+        return unique_deltas(self.index.asi8)
+
+    @cache_readonly
+    def is_unique(self) -> bool:
+        return len(self.deltas) == 1
+
+    @cache_readonly
+    def is_unique_asi8(self) -> bool:
+        return len(self.deltas_asi8) == 1
+
+    def get_freq(self) -> str | None:
+        """
+        Find the appropriate frequency string to describe the inferred
+        frequency of self.i8values
+
+        Returns
+        -------
+        str or None
+        """
+        if not self.is_monotonic or not self.index._is_unique:
+            return None
+
+        delta = self.deltas[0]
+        if delta and _is_multiple(delta, _ONE_DAY):
+            return self._infer_daily_rule()
+
+        # Business hourly, maybe. 17: one day / 65: one weekend
+        if self.hour_deltas in ([1, 17], [1, 65], [1, 17, 65]):
+            return "BH"
+
+        # Possibly intraday frequency.  Here we use the
+        # original .asi8 values as the modified values
+        # will not work around DST transitions.  See #8772
+        if not self.is_unique_asi8:
+            return None
+
+        delta = self.deltas_asi8[0]
+        if _is_multiple(delta, _ONE_HOUR):
+            # Hours
+            return _maybe_add_count("H", delta / _ONE_HOUR)
+        elif _is_multiple(delta, _ONE_MINUTE):
+            # Minutes
+            return _maybe_add_count("T", delta / _ONE_MINUTE)
+        elif _is_multiple(delta, _ONE_SECOND):
+            # Seconds
+            return _maybe_add_count("S", delta / _ONE_SECOND)
+        elif _is_multiple(delta, _ONE_MILLI):
+            # Milliseconds
+            return _maybe_add_count("L", delta / _ONE_MILLI)
+        elif _is_multiple(delta, _ONE_MICRO):
+            # Microseconds
+            return _maybe_add_count("U", delta / _ONE_MICRO)
+        else:
+            # Nanoseconds
+            return _maybe_add_count("N", delta)
+
+    @cache_readonly
+    def day_deltas(self):
+        return [x / _ONE_DAY for x in self.deltas]
+
+    @cache_readonly
+    def hour_deltas(self):
+        return [x / _ONE_HOUR for x in self.deltas]
+
+    @cache_readonly
+    def fields(self) -> np.ndarray:  # structured array of fields
+        return build_field_sarray(self.i8values)
+
+    @cache_readonly
+    def rep_stamp(self):
+        return Timestamp(self.i8values[0])
+
+    def month_position_check(self):
+        return month_position_check(self.fields, self.index.dayofweek)
+
+    @cache_readonly
+    def mdiffs(self) -> npt.NDArray[np.int64]:
+        nmonths = self.fields["Y"] * 12 + self.fields["M"]
+        return unique_deltas(nmonths.astype("i8"))
+
+    @cache_readonly
+    def ydiffs(self) -> npt.NDArray[np.int64]:
+        return unique_deltas(self.fields["Y"].astype("i8"))
+
+    def _infer_daily_rule(self) -> str | None:
+        annual_rule = self._get_annual_rule()
+        if annual_rule:
+            nyears = self.ydiffs[0]
+            month = MONTH_ALIASES[self.rep_stamp.month]
+            alias = f"{annual_rule}-{month}"
+            return _maybe_add_count(alias, nyears)
+
+        quarterly_rule = self._get_quarterly_rule()
+        if quarterly_rule:
+            nquarters = self.mdiffs[0] / 3
+            mod_dict = {0: 12, 2: 11, 1: 10}
+            month = MONTH_ALIASES[mod_dict[self.rep_stamp.month % 3]]
+            alias = f"{quarterly_rule}-{month}"
+            return _maybe_add_count(alias, nquarters)
+
+        monthly_rule = self._get_monthly_rule()
+        if monthly_rule:
+            return _maybe_add_count(monthly_rule, self.mdiffs[0])
+
+        if self.is_unique:
+            return self._get_daily_rule()
+
+        if self._is_business_daily():
+            return "B"
+
+        wom_rule = self._get_wom_rule()
+        if wom_rule:
+            return wom_rule
+
+        return None
+
+    def _get_daily_rule(self) -> str | None:
+        days = self.deltas[0] / _ONE_DAY
+        if days % 7 == 0:
+            # Weekly
+            wd = int_to_weekday[self.rep_stamp.weekday()]
+            alias = f"W-{wd}"
+            return _maybe_add_count(alias, days / 7)
+        else:
+            return _maybe_add_count("D", days)
+
+    def _get_annual_rule(self) -> str | None:
+        if len(self.ydiffs) > 1:
+            return None
+
+        if len(unique(self.fields["M"])) > 1:
+            return None
+
+        pos_check = self.month_position_check()
+        return {"cs": "AS", "bs": "BAS", "ce": "A", "be": "BA"}.get(pos_check)
+
+    def _get_quarterly_rule(self) -> str | None:
+        if len(self.mdiffs) > 1:
+            return None
+
+        if not self.mdiffs[0] % 3 == 0:
+            return None
+
+        pos_check = self.month_position_check()
+        return {"cs": "QS", "bs": "BQS", "ce": "Q", "be": "BQ"}.get(pos_check)
+
+    def _get_monthly_rule(self) -> str | None:
+        if len(self.mdiffs) > 1:
+            return None
+        pos_check = self.month_position_check()
+        return {"cs": "MS", "bs": "BMS", "ce": "M", "be": "BM"}.get(pos_check)
+
+    def _is_business_daily(self) -> bool:
+        # quick check: cannot be business daily
+        if self.day_deltas != [1, 3]:
+            return False
+
+        # probably business daily, but need to confirm
+        first_weekday = self.index[0].weekday()
+        shifts = np.diff(self.index.asi8)
+        shifts = np.floor_divide(shifts, _ONE_DAY)
+        weekdays = np.mod(first_weekday + np.cumsum(shifts), 7)
+
+        return bool(
+            np.all(
+                ((weekdays == 0) & (shifts == 3))
+                | ((weekdays > 0) & (weekdays <= 4) & (shifts == 1))
+            )
+        )
+
+    def _get_wom_rule(self) -> str | None:
+        # FIXME: dont leave commented-out
+        #         wdiffs = unique(np.diff(self.index.week))
+        # We also need -47, -49, -48 to catch index spanning year boundary
+        #     if not lib.ismember(wdiffs, set([4, 5, -47, -49, -48])).all():
+        #         return None
+
+        weekdays = unique(self.index.weekday)
+        if len(weekdays) > 1:
+            return None
+
+        week_of_months = unique((self.index.day - 1) // 7)
+        # Only attempt to infer up to WOM-4. See #9425
+        week_of_months = week_of_months[week_of_months < 4]
+        if len(week_of_months) == 0 or len(week_of_months) > 1:
+            return None
+
+        # get which week
+        week = week_of_months[0] + 1
+        wd = int_to_weekday[weekdays[0]]
+
+        return f"WOM-{week}{wd}"
+
+
+class _TimedeltaFrequencyInferer(_FrequencyInferer):
+    def _infer_daily_rule(self):
+        if self.is_unique:
+            return self._get_daily_rule()
+
+
+def _is_multiple(us, mult: int) -> bool:
+    return us % mult == 0
+
+
+def _maybe_add_count(base: str, count: float) -> str:
+    if count != 1:
+        assert count == int(count)
+        count = int(count)
+        return f"{count}{base}"
+    else:
+        return base
+
+
+# ----------------------------------------------------------------------
+# Frequency comparison
+
+
+def is_subperiod(source, target) -> bool:
+    """
+    Returns True if downsampling is possible between source and target
+    frequencies
+
+    Parameters
+    ----------
+    source : str or DateOffset
+        Frequency converting from
+    target : str or DateOffset
+        Frequency converting to
+
+    Returns
+    -------
+    bool
+    """
+
+    if target is None or source is None:
+        return False
+    source = _maybe_coerce_freq(source)
+    target = _maybe_coerce_freq(target)
+
+    if _is_annual(target):
+        if _is_quarterly(source):
+            return _quarter_months_conform(
+                get_rule_month(source), get_rule_month(target)
+            )
+        return source in {"D", "C", "B", "M", "H", "T", "S", "L", "U", "N"}
+    elif _is_quarterly(target):
+        return source in {"D", "C", "B", "M", "H", "T", "S", "L", "U", "N"}
+    elif _is_monthly(target):
+        return source in {"D", "C", "B", "H", "T", "S", "L", "U", "N"}
+    elif _is_weekly(target):
+        return source in {target, "D", "C", "B", "H", "T", "S", "L", "U", "N"}
+    elif target == "B":
+        return source in {"B", "H", "T", "S", "L", "U", "N"}
+    elif target == "C":
+        return source in {"C", "H", "T", "S", "L", "U", "N"}
+    elif target == "D":
+        return source in {"D", "H", "T", "S", "L", "U", "N"}
+    elif target == "H":
+        return source in {"H", "T", "S", "L", "U", "N"}
+    elif target == "T":
+        return source in {"T", "S", "L", "U", "N"}
+    elif target == "S":
+        return source in {"S", "L", "U", "N"}
+    elif target == "L":
+        return source in {"L", "U", "N"}
+    elif target == "U":
+        return source in {"U", "N"}
+    elif target == "N":
+        return source in {"N"}
+    else:
+        return False
+
+
+def is_superperiod(source, target) -> bool:
+    """
+    Returns True if upsampling is possible between source and target
+    frequencies
+
+    Parameters
+    ----------
+    source : str or DateOffset
+        Frequency converting from
+    target : str or DateOffset
+        Frequency converting to
+
+    Returns
+    -------
+    bool
+    """
+    if target is None or source is None:
+        return False
+    source = _maybe_coerce_freq(source)
+    target = _maybe_coerce_freq(target)
+
+    if _is_annual(source):
+        if _is_annual(target):
+            return get_rule_month(source) == get_rule_month(target)
+
+        if _is_quarterly(target):
+            smonth = get_rule_month(source)
+            tmonth = get_rule_month(target)
+            return _quarter_months_conform(smonth, tmonth)
+        return target in {"D", "C", "B", "M", "H", "T", "S", "L", "U", "N"}
+    elif _is_quarterly(source):
+        return target in {"D", "C", "B", "M", "H", "T", "S", "L", "U", "N"}
+    elif _is_monthly(source):
+        return target in {"D", "C", "B", "H", "T", "S", "L", "U", "N"}
+    elif _is_weekly(source):
+        return target in {source, "D", "C", "B", "H", "T", "S", "L", "U", "N"}
+    elif source == "B":
+        return target in {"D", "C", "B", "H", "T", "S", "L", "U", "N"}
+    elif source == "C":
+        return target in {"D", "C", "B", "H", "T", "S", "L", "U", "N"}
+    elif source == "D":
+        return target in {"D", "C", "B", "H", "T", "S", "L", "U", "N"}
+    elif source == "H":
+        return target in {"H", "T", "S", "L", "U", "N"}
+    elif source == "T":
+        return target in {"T", "S", "L", "U", "N"}
+    elif source == "S":
+        return target in {"S", "L", "U", "N"}
+    elif source == "L":
+        return target in {"L", "U", "N"}
+    elif source == "U":
+        return target in {"U", "N"}
+    elif source == "N":
+        return target in {"N"}
+    else:
+        return False
+
+
+def _maybe_coerce_freq(code) -> str:
+    """we might need to coerce a code to a rule_code
+    and uppercase it
+
+    Parameters
+    ----------
+    source : str or DateOffset
+        Frequency converting from
+
+    Returns
+    -------
+    str
+    """
+    assert code is not None
+    if isinstance(code, DateOffset):
+        code = code.rule_code
+    return code.upper()
+
+
+def _quarter_months_conform(source: str, target: str) -> bool:
+    snum = MONTH_NUMBERS[source]
+    tnum = MONTH_NUMBERS[target]
+    return snum % 3 == tnum % 3
+
+
+def _is_annual(rule: str) -> bool:
+    rule = rule.upper()
+    return rule == "A" or rule.startswith("A-")
+
+
+def _is_quarterly(rule: str) -> bool:
+    rule = rule.upper()
+    return rule == "Q" or rule.startswith("Q-") or rule.startswith("BQ")
+
+
+def _is_monthly(rule: str) -> bool:
+    rule = rule.upper()
+    return rule == "M" or rule == "BM"
+
+
+def _is_weekly(rule: str) -> bool:
+    rule = rule.upper()
+    return rule == "W" or rule.startswith("W-")

.venv/Lib/site-packages/pandas/tseries/holiday.py

@@ -0,0 +1,582 @@
+from __future__ import annotations
+
+from datetime import (
+    datetime,
+    timedelta,
+)
+import warnings
+
+from dateutil.relativedelta import (  # noqa:F401
+    FR,
+    MO,
+    SA,
+    SU,
+    TH,
+    TU,
+    WE,
+)
+import numpy as np
+
+from pandas.errors import PerformanceWarning
+
+from pandas import (
+    DateOffset,
+    DatetimeIndex,
+    Series,
+    Timestamp,
+    concat,
+    date_range,
+)
+
+from pandas.tseries.offsets import (
+    Day,
+    Easter,
+)
+
+
+def next_monday(dt: datetime) -> datetime:
+    """
+    If holiday falls on Saturday, use following Monday instead;
+    if holiday falls on Sunday, use Monday instead
+    """
+    if dt.weekday() == 5:
+        return dt + timedelta(2)
+    elif dt.weekday() == 6:
+        return dt + timedelta(1)
+    return dt
+
+
+def next_monday_or_tuesday(dt: datetime) -> datetime:
+    """
+    For second holiday of two adjacent ones!
+    If holiday falls on Saturday, use following Monday instead;
+    if holiday falls on Sunday or Monday, use following Tuesday instead
+    (because Monday is already taken by adjacent holiday on the day before)
+    """
+    dow = dt.weekday()
+    if dow == 5 or dow == 6:
+        return dt + timedelta(2)
+    elif dow == 0:
+        return dt + timedelta(1)
+    return dt
+
+
+def previous_friday(dt: datetime) -> datetime:
+    """
+    If holiday falls on Saturday or Sunday, use previous Friday instead.
+    """
+    if dt.weekday() == 5:
+        return dt - timedelta(1)
+    elif dt.weekday() == 6:
+        return dt - timedelta(2)
+    return dt
+
+
+def sunday_to_monday(dt: datetime) -> datetime:
+    """
+    If holiday falls on Sunday, use day thereafter (Monday) instead.
+    """
+    if dt.weekday() == 6:
+        return dt + timedelta(1)
+    return dt
+
+
+def weekend_to_monday(dt: datetime) -> datetime:
+    """
+    If holiday falls on Sunday or Saturday,
+    use day thereafter (Monday) instead.
+    Needed for holidays such as Christmas observation in Europe
+    """
+    if dt.weekday() == 6:
+        return dt + timedelta(1)
+    elif dt.weekday() == 5:
+        return dt + timedelta(2)
+    return dt
+
+
+def nearest_workday(dt: datetime) -> datetime:
+    """
+    If holiday falls on Saturday, use day before (Friday) instead;
+    if holiday falls on Sunday, use day thereafter (Monday) instead.
+    """
+    if dt.weekday() == 5:
+        return dt - timedelta(1)
+    elif dt.weekday() == 6:
+        return dt + timedelta(1)
+    return dt
+
+
+def next_workday(dt: datetime) -> datetime:
+    """
+    returns next weekday used for observances
+    """
+    dt += timedelta(days=1)
+    while dt.weekday() > 4:
+        # Mon-Fri are 0-4
+        dt += timedelta(days=1)
+    return dt
+
+
+def previous_workday(dt: datetime) -> datetime:
+    """
+    returns previous weekday used for observances
+    """
+    dt -= timedelta(days=1)
+    while dt.weekday() > 4:
+        # Mon-Fri are 0-4
+        dt -= timedelta(days=1)
+    return dt
+
+
+def before_nearest_workday(dt: datetime) -> datetime:
+    """
+    returns previous workday after nearest workday
+    """
+    return previous_workday(nearest_workday(dt))
+
+
+def after_nearest_workday(dt: datetime) -> datetime:
+    """
+    returns next workday after nearest workday
+    needed for Boxing day or multiple holidays in a series
+    """
+    return next_workday(nearest_workday(dt))
+
+
+class Holiday:
+    """
+    Class that defines a holiday with start/end dates and rules
+    for observance.
+    """
+
+    def __init__(
+        self,
+        name,
+        year=None,
+        month=None,
+        day=None,
+        offset=None,
+        observance=None,
+        start_date=None,
+        end_date=None,
+        days_of_week=None,
+    ):
+        """
+        Parameters
+        ----------
+        name : str
+            Name of the holiday , defaults to class name
+        offset : array of pandas.tseries.offsets or
+                class from pandas.tseries.offsets
+            computes offset from date
+        observance: function
+            computes when holiday is given a pandas Timestamp
+        days_of_week:
+            provide a tuple of days e.g  (0,1,2,3,) for Monday Through Thursday
+            Monday=0,..,Sunday=6
+
+        Examples
+        --------
+        >>> from pandas.tseries.holiday import Holiday, nearest_workday
+        >>> from dateutil.relativedelta import MO
+
+        >>> USMemorialDay = Holiday(
+        ...     "Memorial Day", month=5, day=31, offset=pd.DateOffset(weekday=MO(-1))
+        ... )
+        >>> USMemorialDay
+        Holiday: Memorial Day (month=5, day=31, offset=<DateOffset: weekday=MO(-1)>)
+
+        >>> USLaborDay = Holiday(
+        ...     "Labor Day", month=9, day=1, offset=pd.DateOffset(weekday=MO(1))
+        ... )
+        >>> USLaborDay
+        Holiday: Labor Day (month=9, day=1, offset=<DateOffset: weekday=MO(+1)>)
+
+        >>> July3rd = Holiday("July 3rd", month=7, day=3)
+        >>> July3rd
+        Holiday: July 3rd (month=7, day=3, )
+
+        >>> NewYears = Holiday(
+        ...     "New Years Day", month=1,  day=1,
+        ...      observance=nearest_workday
+        ... )
+        >>> NewYears  # doctest: +SKIP
+        Holiday: New Years Day (
+            month=1, day=1, observance=<function nearest_workday at 0x66545e9bc440>
+        )
+
+        >>> July3rd = Holiday("July 3rd", month=7, day=3, days_of_week=(0, 1, 2, 3))
+        >>> July3rd
+        Holiday: July 3rd (month=7, day=3, )
+        """
+        if offset is not None and observance is not None:
+            raise NotImplementedError("Cannot use both offset and observance.")
+
+        self.name = name
+        self.year = year
+        self.month = month
+        self.day = day
+        self.offset = offset
+        self.start_date = (
+            Timestamp(start_date) if start_date is not None else start_date
+        )
+        self.end_date = Timestamp(end_date) if end_date is not None else end_date
+        self.observance = observance
+        assert days_of_week is None or type(days_of_week) == tuple
+        self.days_of_week = days_of_week
+
+    def __repr__(self) -> str:
+        info = ""
+        if self.year is not None:
+            info += f"year={self.year}, "
+        info += f"month={self.month}, day={self.day}, "
+
+        if self.offset is not None:
+            info += f"offset={self.offset}"
+
+        if self.observance is not None:
+            info += f"observance={self.observance}"
+
+        repr = f"Holiday: {self.name} ({info})"
+        return repr
+
+    def dates(self, start_date, end_date, return_name=False):
+        """
+        Calculate holidays observed between start date and end date
+
+        Parameters
+        ----------
+        start_date : starting date, datetime-like, optional
+        end_date : ending date, datetime-like, optional
+        return_name : bool, optional, default=False
+            If True, return a series that has dates and holiday names.
+            False will only return dates.
+        """
+        start_date = Timestamp(start_date)
+        end_date = Timestamp(end_date)
+
+        filter_start_date = start_date
+        filter_end_date = end_date
+
+        if self.year is not None:
+            dt = Timestamp(datetime(self.year, self.month, self.day))
+            if return_name:
+                return Series(self.name, index=[dt])
+            else:
+                return [dt]
+
+        dates = self._reference_dates(start_date, end_date)
+        holiday_dates = self._apply_rule(dates)
+        if self.days_of_week is not None:
+            holiday_dates = holiday_dates[
+                np.in1d(holiday_dates.dayofweek, self.days_of_week)
+            ]
+
+        if self.start_date is not None:
+            filter_start_date = max(
+                self.start_date.tz_localize(filter_start_date.tz), filter_start_date
+            )
+        if self.end_date is not None:
+            filter_end_date = min(
+                self.end_date.tz_localize(filter_end_date.tz), filter_end_date
+            )
+        holiday_dates = holiday_dates[
+            (holiday_dates >= filter_start_date) & (holiday_dates <= filter_end_date)
+        ]
+        if return_name:
+            return Series(self.name, index=holiday_dates)
+        return holiday_dates
+
+    def _reference_dates(self, start_date, end_date):
+        """
+        Get reference dates for the holiday.
+
+        Return reference dates for the holiday also returning the year
+        prior to the start_date and year following the end_date.  This ensures
+        that any offsets to be applied will yield the holidays within
+        the passed in dates.
+        """
+        if self.start_date is not None:
+            start_date = self.start_date.tz_localize(start_date.tz)
+
+        if self.end_date is not None:
+            end_date = self.end_date.tz_localize(start_date.tz)
+
+        year_offset = DateOffset(years=1)
+        reference_start_date = Timestamp(
+            datetime(start_date.year - 1, self.month, self.day)
+        )
+
+        reference_end_date = Timestamp(
+            datetime(end_date.year + 1, self.month, self.day)
+        )
+        # Don't process unnecessary holidays
+        dates = date_range(
+            start=reference_start_date,
+            end=reference_end_date,
+            freq=year_offset,
+            tz=start_date.tz,
+        )
+
+        return dates
+
+    def _apply_rule(self, dates):
+        """
+        Apply the given offset/observance to a DatetimeIndex of dates.
+
+        Parameters
+        ----------
+        dates : DatetimeIndex
+            Dates to apply the given offset/observance rule
+
+        Returns
+        -------
+        Dates with rules applied
+        """
+        if self.observance is not None:
+            return dates.map(lambda d: self.observance(d))
+
+        if self.offset is not None:
+            if not isinstance(self.offset, list):
+                offsets = [self.offset]
+            else:
+                offsets = self.offset
+            for offset in offsets:
+
+                # if we are adding a non-vectorized value
+                # ignore the PerformanceWarnings:
+                with warnings.catch_warnings():
+                    warnings.simplefilter("ignore", PerformanceWarning)
+                    dates += offset
+        return dates
+
+
+holiday_calendars = {}
+
+
+def register(cls):
+    try:
+        name = cls.name
+    except AttributeError:
+        name = cls.__name__
+    holiday_calendars[name] = cls
+
+
+def get_calendar(name):
+    """
+    Return an instance of a calendar based on its name.
+
+    Parameters
+    ----------
+    name : str
+        Calendar name to return an instance of
+    """
+    return holiday_calendars[name]()
+
+
+class HolidayCalendarMetaClass(type):
+    def __new__(cls, clsname, bases, attrs):
+        calendar_class = super().__new__(cls, clsname, bases, attrs)
+        register(calendar_class)
+        return calendar_class
+
+
+class AbstractHolidayCalendar(metaclass=HolidayCalendarMetaClass):
+    """
+    Abstract interface to create holidays following certain rules.
+    """
+
+    rules: list[Holiday] = []
+    start_date = Timestamp(datetime(1970, 1, 1))
+    end_date = Timestamp(datetime(2200, 12, 31))
+    _cache = None
+
+    def __init__(self, name=None, rules=None):
+        """
+        Initializes holiday object with a given set a rules.  Normally
+        classes just have the rules defined within them.
+
+        Parameters
+        ----------
+        name : str
+            Name of the holiday calendar, defaults to class name
+        rules : array of Holiday objects
+            A set of rules used to create the holidays.
+        """
+        super().__init__()
+        if name is None:
+            name = type(self).__name__
+        self.name = name
+
+        if rules is not None:
+            self.rules = rules
+
+    def rule_from_name(self, name):
+        for rule in self.rules:
+            if rule.name == name:
+                return rule
+
+        return None
+
+    def holidays(self, start=None, end=None, return_name=False):
+        """
+        Returns a curve with holidays between start_date and end_date
+
+        Parameters
+        ----------
+        start : starting date, datetime-like, optional
+        end : ending date, datetime-like, optional
+        return_name : bool, optional
+            If True, return a series that has dates and holiday names.
+            False will only return a DatetimeIndex of dates.
+
+        Returns
+        -------
+            DatetimeIndex of holidays
+        """
+        if self.rules is None:
+            raise Exception(
+                f"Holiday Calendar {self.name} does not have any rules specified"
+            )
+
+        if start is None:
+            start = AbstractHolidayCalendar.start_date
+
+        if end is None:
+            end = AbstractHolidayCalendar.end_date
+
+        start = Timestamp(start)
+        end = Timestamp(end)
+
+        # If we don't have a cache or the dates are outside the prior cache, we
+        # get them again
+        if self._cache is None or start < self._cache[0] or end > self._cache[1]:
+            pre_holidays = [
+                rule.dates(start, end, return_name=True) for rule in self.rules
+            ]
+            if pre_holidays:
+                holidays = concat(pre_holidays)
+            else:
+                holidays = Series(index=DatetimeIndex([]), dtype=object)
+
+            self._cache = (start, end, holidays.sort_index())
+
+        holidays = self._cache[2]
+        holidays = holidays[start:end]
+
+        if return_name:
+            return holidays
+        else:
+            return holidays.index
+
+    @staticmethod
+    def merge_class(base, other):
+        """
+        Merge holiday calendars together. The base calendar
+        will take precedence to other. The merge will be done
+        based on each holiday's name.
+
+        Parameters
+        ----------
+        base : AbstractHolidayCalendar
+          instance/subclass or array of Holiday objects
+        other : AbstractHolidayCalendar
+          instance/subclass or array of Holiday objects
+        """
+        try:
+            other = other.rules
+        except AttributeError:
+            pass
+
+        if not isinstance(other, list):
+            other = [other]
+        other_holidays = {holiday.name: holiday for holiday in other}
+
+        try:
+            base = base.rules
+        except AttributeError:
+            pass
+
+        if not isinstance(base, list):
+            base = [base]
+        base_holidays = {holiday.name: holiday for holiday in base}
+
+        other_holidays.update(base_holidays)
+        return list(other_holidays.values())
+
+    def merge(self, other, inplace=False):
+        """
+        Merge holiday calendars together.  The caller's class
+        rules take precedence.  The merge will be done
+        based on each holiday's name.
+
+        Parameters
+        ----------
+        other : holiday calendar
+        inplace : bool (default=False)
+            If True set rule_table to holidays, else return array of Holidays
+        """
+        holidays = self.merge_class(self, other)
+        if inplace:
+            self.rules = holidays
+        else:
+            return holidays
+
+
+USMemorialDay = Holiday(
+    "Memorial Day", month=5, day=31, offset=DateOffset(weekday=MO(-1))
+)
+USLaborDay = Holiday("Labor Day", month=9, day=1, offset=DateOffset(weekday=MO(1)))
+USColumbusDay = Holiday(
+    "Columbus Day", month=10, day=1, offset=DateOffset(weekday=MO(2))
+)
+USThanksgivingDay = Holiday(
+    "Thanksgiving Day", month=11, day=1, offset=DateOffset(weekday=TH(4))
+)
+USMartinLutherKingJr = Holiday(
+    "Birthday of Martin Luther King, Jr.",
+    start_date=datetime(1986, 1, 1),
+    month=1,
+    day=1,
+    offset=DateOffset(weekday=MO(3)),
+)
+USPresidentsDay = Holiday(
+    "Washington’s Birthday", month=2, day=1, offset=DateOffset(weekday=MO(3))
+)
+GoodFriday = Holiday("Good Friday", month=1, day=1, offset=[Easter(), Day(-2)])
+
+EasterMonday = Holiday("Easter Monday", month=1, day=1, offset=[Easter(), Day(1)])
+
+
+class USFederalHolidayCalendar(AbstractHolidayCalendar):
+    """
+    US Federal Government Holiday Calendar based on rules specified by:
+    https://www.opm.gov/policy-data-oversight/
+       snow-dismissal-procedures/federal-holidays/
+    """
+
+    rules = [
+        Holiday("New Year's Day", month=1, day=1, observance=nearest_workday),
+        USMartinLutherKingJr,
+        USPresidentsDay,
+        USMemorialDay,
+        Holiday(
+            "Juneteenth National Independence Day",
+            month=6,
+            day=19,
+            start_date="2021-06-18",
+            observance=nearest_workday,
+        ),
+        Holiday("Independence Day", month=7, day=4, observance=nearest_workday),
+        USLaborDay,
+        USColumbusDay,
+        Holiday("Veterans Day", month=11, day=11, observance=nearest_workday),
+        USThanksgivingDay,
+        Holiday("Christmas Day", month=12, day=25, observance=nearest_workday),
+    ]
+
+
+def HolidayCalendarFactory(name, base, other, base_class=AbstractHolidayCalendar):
+    rules = AbstractHolidayCalendar.merge_class(base, other)
+    calendar_class = type(name, (base_class,), {"rules": rules, "name": name})
+    return calendar_class

.venv/Lib/site-packages/pandas/tseries/offsets.py

@@ -0,0 +1,83 @@
+from pandas._libs.tslibs.offsets import (  # noqa:F401
+    FY5253,
+    BaseOffset,
+    BDay,
+    BMonthBegin,
+    BMonthEnd,
+    BQuarterBegin,
+    BQuarterEnd,
+    BusinessDay,
+    BusinessHour,
+    BusinessMonthBegin,
+    BusinessMonthEnd,
+    BYearBegin,
+    BYearEnd,
+    CBMonthBegin,
+    CBMonthEnd,
+    CDay,
+    CustomBusinessDay,
+    CustomBusinessHour,
+    CustomBusinessMonthBegin,
+    CustomBusinessMonthEnd,
+    DateOffset,
+    Day,
+    Easter,
+    FY5253Quarter,
+    Hour,
+    LastWeekOfMonth,
+    Micro,
+    Milli,
+    Minute,
+    MonthBegin,
+    MonthEnd,
+    Nano,
+    QuarterBegin,
+    QuarterEnd,
+    Second,
+    SemiMonthBegin,
+    SemiMonthEnd,
+    Tick,
+    Week,
+    WeekOfMonth,
+    YearBegin,
+    YearEnd,
+)
+
+__all__ = [
+    "Day",
+    "BusinessDay",
+    "BDay",
+    "CustomBusinessDay",
+    "CDay",
+    "CBMonthEnd",
+    "CBMonthBegin",
+    "MonthBegin",
+    "BMonthBegin",
+    "MonthEnd",
+    "BMonthEnd",
+    "SemiMonthEnd",
+    "SemiMonthBegin",
+    "BusinessHour",
+    "CustomBusinessHour",
+    "YearBegin",
+    "BYearBegin",
+    "YearEnd",
+    "BYearEnd",
+    "QuarterBegin",
+    "BQuarterBegin",
+    "QuarterEnd",
+    "BQuarterEnd",
+    "LastWeekOfMonth",
+    "FY5253Quarter",
+    "FY5253",
+    "Week",
+    "WeekOfMonth",
+    "Easter",
+    "Hour",
+    "Minute",
+    "Second",
+    "Milli",
+    "Micro",
+    "Nano",
+    "DateOffset",
+]