Merge main

Author: datapythonista

doc/source/whatsnew/v3.0.0.rst

@@ -64,6 +64,8 @@ Other enhancements
 - :meth:`Series.nlargest` uses a 'stable' sort internally and will preserve original ordering.
 - :class:`ArrowDtype` now supports ``pyarrow.JsonType`` (:issue:`60958`)
 - :class:`DataFrameGroupBy` and :class:`SeriesGroupBy` methods ``sum``, ``mean``, ``median``, ``prod``, ``min``, ``max``, ``std``, ``var`` and ``sem`` now accept ``skipna`` parameter (:issue:`15675`)
+- :class:`Easter` has gained a new constructor argument ``method`` which specifies the method used to calculate Easter — for example, Orthodox Easter (:issue:`61665`)
+- :class:`Holiday` has gained the constructor argument and field ``exclude_dates`` to exclude specific datetimes from a custom holiday calendar (:issue:`54382`)
 - :class:`Rolling` and :class:`Expanding` now support ``nunique`` (:issue:`26958`)
 - :class:`Rolling` and :class:`Expanding` now support aggregations ``first`` and ``last`` (:issue:`33155`)
 - :func:`read_parquet` accepts ``to_pandas_kwargs`` which are forwarded to :meth:`pyarrow.Table.to_pandas` which enables passing additional keywords to customize the conversion to pandas, such as ``maps_as_pydicts`` to read the Parquet map data type as python dictionaries (:issue:`56842`)
@@ -716,6 +718,7 @@ Numeric
 - Bug in :meth:`DataFrame.cov` raises a ``TypeError`` instead of returning potentially incorrect results or other errors (:issue:`53115`)
 - Bug in :meth:`DataFrame.quantile` where the column type was not preserved when ``numeric_only=True`` with a list-like ``q`` produced an empty result (:issue:`59035`)
 - Bug in :meth:`Series.dot` returning ``object`` dtype for :class:`ArrowDtype` and nullable-dtype data (:issue:`61375`)
+- Bug in :meth:`Series.std` and :meth:`Series.var` when using complex-valued data (:issue:`61645`)
 - Bug in ``np.matmul`` with :class:`Index` inputs raising a ``TypeError`` (:issue:`57079`)
 
 Conversion

pandas/_libs/tslibs/offsets.pyi

@@ -230,7 +230,13 @@ class FY5253Quarter(FY5253Mixin):
         variation: Literal["nearest", "last"] = ...,
     ) -> None: ...
 
-class Easter(SingleConstructorOffset): ...
+class Easter(SingleConstructorOffset):
+    def __init__(
+        self,
+        n: int = ...,
+        normalize: bool = ...,
+        method: int = ...,
+    ) -> None: ...
 
 class _CustomBusinessMonth(BusinessMixin):
     def __init__(

pandas/_libs/tslibs/offsets.pyx

@@ -4520,6 +4520,12 @@ cdef class Easter(SingleConstructorOffset):
         The number of years represented.
     normalize : bool, default False
         Normalize start/end dates to midnight before generating date range.
+    method : int, default 3
+        The method used to calculate the date of Easter. Valid options are:
+        - 1 (EASTER_JULIAN): Original calculation in Julian calendar
+        - 2 (EASTER_ORTHODOX): Original method, date converted to Gregorian calendar
+        - 3 (EASTER_WESTERN): Revised method, in Gregorian calendar
+        These constants are defined in the `dateutil.easter` module.
 
     See Also
     --------
@@ -4532,15 +4538,32 @@ cdef class Easter(SingleConstructorOffset):
     Timestamp('2022-04-17 00:00:00')
     """
 
+    _attributes = tuple(["n", "normalize", "method"])
+
+    cdef readonly:
+        int method
+
+    from dateutil.easter import EASTER_WESTERN
+
+    def __init__(self, n=1, normalize=False, method=EASTER_WESTERN):
+        BaseOffset.__init__(self, n, normalize)
+
+        self.method = method
+
+        if method < 1 or method > 3:
+            raise ValueError(f"Method must be 1<=method<=3, got {method}")
+
     cpdef __setstate__(self, state):
+        from dateutil.easter import EASTER_WESTERN
         self.n = state.pop("n")
         self.normalize = state.pop("normalize")
+        self.method = state.pop("method", EASTER_WESTERN)
 
     @apply_wraps
     def _apply(self, other: datetime) -> datetime:
         from dateutil.easter import easter
 
-        current_easter = easter(other.year)
+        current_easter = easter(other.year, method=self.method)
         current_easter = datetime(
             current_easter.year, current_easter.month, current_easter.day
         )
@@ -4555,7 +4578,7 @@ cdef class Easter(SingleConstructorOffset):
 
         # NOTE: easter returns a datetime.date so we have to convert to type of
         # other
-        new = easter(other.year + n)
+        new = easter(other.year + n, method=self.method)
         new = datetime(
             new.year,
             new.month,
@@ -4573,7 +4596,7 @@ cdef class Easter(SingleConstructorOffset):
 
         from dateutil.easter import easter
 
-        return date(dt.year, dt.month, dt.day) == easter(dt.year)
+        return date(dt.year, dt.month, dt.day) == easter(dt.year, method=self.method)
 
 
 # ----------------------------------------------------------------------

pandas/core/nanops.py

@@ -1014,7 +1014,11 @@ def nanvar(
     avg = _ensure_numeric(values.sum(axis=axis, dtype=np.float64)) / count
     if axis is not None:
         avg = np.expand_dims(avg, axis)
-    sqr = _ensure_numeric((avg - values) ** 2)
+    if values.dtype.kind == "c":
+        # Need to use absolute value for complex numbers.
+        sqr = _ensure_numeric(abs(avg - values) ** 2)
+    else:
+        sqr = _ensure_numeric((avg - values) ** 2)
     if mask is not None:
         np.putmask(sqr, mask, 0)
     result = sqr.sum(axis=axis, dtype=np.float64) / d

pandas/tests/extension/base/setitem.py

@@ -440,11 +440,11 @@ def test_delitem_series(self, data):
         tm.assert_series_equal(ser, expected)
 
     def test_setitem_invalid(self, data, invalid_scalar):
-        msg = ""  # messages vary by subclass, so we do not test it
-        with pytest.raises((ValueError, TypeError), match=msg):
+        # messages vary by subclass, so we do not test it
+        with pytest.raises((ValueError, TypeError), match=None):
             data[0] = invalid_scalar
 
-        with pytest.raises((ValueError, TypeError), match=msg):
+        with pytest.raises((ValueError, TypeError), match=None):
             data[:] = invalid_scalar
 
     def test_setitem_2d_values(self, data):

pandas/tests/reductions/test_reductions.py

@@ -780,6 +780,12 @@ def test_var_masked_array(self, ddof, exp):
         assert result == result_numpy_dtype
         assert result == exp
 
+    def test_var_complex_array(self):
+        # GH#61645
+        ser = Series([-1j, 0j, 1j], dtype=complex)
+        assert ser.var(ddof=1) == 1.0
+        assert ser.std(ddof=1) == 1.0
+
     @pytest.mark.parametrize("dtype", ("m8[ns]", "M8[ns]", "M8[ns, UTC]"))
     def test_empty_timeseries_reductions_return_nat(self, dtype, skipna):
         # covers GH#11245

pandas/tests/tseries/holiday/test_holiday.py

@@ -353,3 +353,104 @@ def test_holidays_with_timezone_specified_but_no_occurences():
     expected_results.index = expected_results.index.as_unit("ns")
 
     tm.assert_equal(test_case, expected_results)
+
+
+def test_holiday_with_exclusion():
+    # GH 54382
+    start = Timestamp("2020-05-01")
+    end = Timestamp("2025-05-31")
+    exclude = DatetimeIndex([Timestamp("2022-05-30")])  # Queen's platinum Jubilee
+
+    queens_jubilee_uk_spring_bank_holiday: Holiday = Holiday(
+        "Queen's Jubilee UK Spring Bank Holiday",
+        month=5,
+        day=31,
+        offset=DateOffset(weekday=MO(-1)),
+        exclude_dates=exclude,
+    )
+
+    result = queens_jubilee_uk_spring_bank_holiday.dates(start, end)
+    expected = DatetimeIndex(
+        [
+            Timestamp("2020-05-25"),
+            Timestamp("2021-05-31"),
+            Timestamp("2023-05-29"),
+            Timestamp("2024-05-27"),
+            Timestamp("2025-05-26"),
+        ],
+        dtype="datetime64[ns]",
+    )
+    tm.assert_index_equal(result, expected)
+
+
+def test_holiday_with_multiple_exclusions():
+    start = Timestamp("2025-01-01")
+    end = Timestamp("2065-12-31")
+    exclude = DatetimeIndex(
+        [
+            Timestamp("2025-01-01"),
+            Timestamp("2042-01-01"),
+            Timestamp("2061-01-01"),
+        ]
+    )  # Yakudoshi new year
+
+    yakudoshi_new_year: Holiday = Holiday(
+        "Yakudoshi New Year", month=1, day=1, exclude_dates=exclude
+    )
+
+    result = yakudoshi_new_year.dates(start, end)
+    expected = DatetimeIndex(
+        [
+            Timestamp("2026-01-01"),
+            Timestamp("2027-01-01"),
+            Timestamp("2028-01-01"),
+            Timestamp("2029-01-01"),
+            Timestamp("2030-01-01"),
+            Timestamp("2031-01-01"),
+            Timestamp("2032-01-01"),
+            Timestamp("2033-01-01"),
+            Timestamp("2034-01-01"),
+            Timestamp("2035-01-01"),
+            Timestamp("2036-01-01"),
+            Timestamp("2037-01-01"),
+            Timestamp("2038-01-01"),
+            Timestamp("2039-01-01"),
+            Timestamp("2040-01-01"),
+            Timestamp("2041-01-01"),
+            Timestamp("2043-01-01"),
+            Timestamp("2044-01-01"),
+            Timestamp("2045-01-01"),
+            Timestamp("2046-01-01"),
+            Timestamp("2047-01-01"),
+            Timestamp("2048-01-01"),
+            Timestamp("2049-01-01"),
+            Timestamp("2050-01-01"),
+            Timestamp("2051-01-01"),
+            Timestamp("2052-01-01"),
+            Timestamp("2053-01-01"),
+            Timestamp("2054-01-01"),
+            Timestamp("2055-01-01"),
+            Timestamp("2056-01-01"),
+            Timestamp("2057-01-01"),
+            Timestamp("2058-01-01"),
+            Timestamp("2059-01-01"),
+            Timestamp("2060-01-01"),
+            Timestamp("2062-01-01"),
+            Timestamp("2063-01-01"),
+            Timestamp("2064-01-01"),
+            Timestamp("2065-01-01"),
+        ],
+        dtype="datetime64[ns]",
+    )
+    tm.assert_index_equal(result, expected)
+
+
+def test_exclude_date_value_error():
+    msg = "exclude_dates must be None or of type DatetimeIndex."
+
+    with pytest.raises(ValueError, match=msg):
+        exclude = [
+            Timestamp("2025-06-10"),
+            Timestamp("2026-06-10"),
+        ]
+        Holiday("National Ice Tea Day", month=6, day=10, exclude_dates=exclude)

pandas/tests/tseries/offsets/test_easter.py

@@ -7,6 +7,10 @@
 
 from datetime import datetime
 
+from dateutil.easter import (
+    EASTER_ORTHODOX,
+    EASTER_WESTERN,
+)
 import pytest
 
 from pandas.tests.tseries.offsets.common import assert_offset_equal
@@ -32,3 +36,115 @@ class TestEaster:
     )
     def test_offset(self, offset, date, expected):
         assert_offset_equal(offset, date, expected)
+
+    @pytest.mark.parametrize(
+        "offset,date,expected",
+        [
+            (Easter(method=EASTER_WESTERN), datetime(2010, 1, 1), datetime(2010, 4, 4)),
+            (
+                Easter(method=EASTER_WESTERN),
+                datetime(2010, 4, 5),
+                datetime(2011, 4, 24),
+            ),
+            (
+                Easter(2, method=EASTER_WESTERN),
+                datetime(2010, 1, 1),
+                datetime(2011, 4, 24),
+            ),
+            (
+                Easter(method=EASTER_WESTERN),
+                datetime(2010, 4, 4),
+                datetime(2011, 4, 24),
+            ),
+            (
+                Easter(2, method=EASTER_WESTERN),
+                datetime(2010, 4, 4),
+                datetime(2012, 4, 8),
+            ),
+            (
+                -Easter(method=EASTER_WESTERN),
+                datetime(2011, 1, 1),
+                datetime(2010, 4, 4),
+            ),
+            (
+                -Easter(method=EASTER_WESTERN),
+                datetime(2010, 4, 5),
+                datetime(2010, 4, 4),
+            ),
+            (
+                -Easter(2, method=EASTER_WESTERN),
+                datetime(2011, 1, 1),
+                datetime(2009, 4, 12),
+            ),
+            (
+                -Easter(method=EASTER_WESTERN),
+                datetime(2010, 4, 4),
+                datetime(2009, 4, 12),
+            ),
+            (
+                -Easter(2, method=EASTER_WESTERN),
+                datetime(2010, 4, 4),
+                datetime(2008, 3, 23),
+            ),
+        ],
+    )
+    def test_western_easter_offset(self, offset, date, expected):
+        assert_offset_equal(offset, date, expected)
+
+    @pytest.mark.parametrize(
+        "offset,date,expected",
+        [
+            (
+                Easter(method=EASTER_ORTHODOX),
+                datetime(2010, 1, 1),
+                datetime(2010, 4, 4),
+            ),
+            (
+                Easter(method=EASTER_ORTHODOX),
+                datetime(2010, 4, 5),
+                datetime(2011, 4, 24),
+            ),
+            (
+                Easter(2, method=EASTER_ORTHODOX),
+                datetime(2010, 1, 1),
+                datetime(2011, 4, 24),
+            ),
+            (
+                Easter(method=EASTER_ORTHODOX),
+                datetime(2010, 4, 4),
+                datetime(2011, 4, 24),
+            ),
+            (
+                Easter(2, method=EASTER_ORTHODOX),
+                datetime(2010, 4, 4),
+                datetime(2012, 4, 15),
+            ),
+            (
+                -Easter(method=EASTER_ORTHODOX),
+                datetime(2011, 1, 1),
+                datetime(2010, 4, 4),
+            ),
+            (
+                -Easter(method=EASTER_ORTHODOX),
+                datetime(2010, 4, 5),
+                datetime(2010, 4, 4),
+            ),
+            (
+                -Easter(2, method=EASTER_ORTHODOX),
+                datetime(2011, 1, 1),
+                datetime(2009, 4, 19),
+            ),
+            (
+                -Easter(method=EASTER_ORTHODOX),
+                datetime(2010, 4, 4),
+                datetime(2009, 4, 19),
+            ),
+            (
+                -Easter(2, method=EASTER_ORTHODOX),
+                datetime(2010, 4, 4),
+                datetime(2008, 4, 27),
+            ),
+        ],
+    )
+    def test_orthodox_easter_offset(self, offset, date, expected):
+        assert_offset_equal(offset, date, expected)

pandas/tests/tseries/offsets/test_offsets.py

@@ -239,7 +239,7 @@ def test_offset_freqstr(self, offset_types):
         offset = _create_offset(offset_types)
 
         freqstr = offset.freqstr
-        if freqstr not in ("<Easter>", "<DateOffset: days=1>", "LWOM-SAT"):
+        if freqstr not in ("<Easter: method=3>", "<DateOffset: days=1>", "LWOM-SAT"):
             code = _get_offset(freqstr)
             assert offset.rule_code == code