Merge remote-tracking branch 'upstream/master' into nullable-int-sum

Author: dsaxton

doc/source/user_guide/timeseries.rst

@@ -772,7 +772,6 @@ There are several time/date properties that one can access from ``Timestamp`` or
     week,"The week ordinal of the year"
     dayofweek,"The number of the day of the week with Monday=0, Sunday=6"
     weekday,"The number of the day of the week with Monday=0, Sunday=6"
-    isocalendar,"The ISO 8601 year, week and day of the date"
     quarter,"Quarter of the date: Jan-Mar = 1, Apr-Jun = 2, etc."
     days_in_month,"The number of days in the month of the datetime"
     is_month_start,"Logical indicating if first day of month (defined by frequency)"
@@ -794,7 +793,7 @@ You may obtain the year, week and day components of the ISO year from the ISO 86
 .. ipython:: python
 
    idx = pd.date_range(start='2019-12-29', freq='D', periods=4)
-   idx.to_series().dt.isocalendar
+   idx.to_series().dt.isocalendar()
 
 .. _timeseries.offsets:
 

doc/source/whatsnew/v1.1.0.rst

@@ -88,7 +88,7 @@ Other enhancements
 - :class:`Series.str` now has a `fullmatch` method that matches a regular expression against the entire string in each row of the series, similar to `re.fullmatch` (:issue:`32806`).
 - :meth:`DataFrame.sample` will now also allow array-like and BitGenerator objects to be passed to ``random_state`` as seeds (:issue:`32503`)
 - :meth:`MultiIndex.union` will now raise `RuntimeWarning` if the object inside are unsortable, pass `sort=False` to suppress this warning (:issue:`33015`)
-- :class:`Series.dt` and :class:`DatatimeIndex` now have an `isocalendar` accessor that returns a :class:`DataFrame` with year, week, and day calculated according to the ISO 8601 calendar (:issue:`33206`).
+- :class:`Series.dt` and :class:`DatatimeIndex` now have an `isocalendar` method that returns a :class:`DataFrame` with year, week, and day calculated according to the ISO 8601 calendar (:issue:`33206`).
 - The :meth:`DataFrame.to_feather` method now supports additional keyword
   arguments (e.g. to set the compression) that are added in pyarrow 0.17
   (:issue:`33422`).

pandas/core/arrays/datetimes.py

@@ -183,7 +183,7 @@ class DatetimeArray(dtl.DatetimeLikeArrayMixin, dtl.TimelikeOps, dtl.DatelikeOps
         "microsecond",
         "nanosecond",
     ]
-    _other_ops = ["date", "time", "timetz", "isocalendar"]
+    _other_ops = ["date", "time", "timetz"]
     _datetimelike_ops = _field_ops + _object_ops + _bool_ops + _other_ops
     _datetimelike_methods = [
         "to_period",
@@ -1242,7 +1242,6 @@ def date(self):
 
         return tslib.ints_to_pydatetime(timestamps, box="date")
 
-    @property
     def isocalendar(self):
         """
         Returns a DataFrame with the year, week, and day calculated according to
@@ -1263,13 +1262,13 @@ def isocalendar(self):
         Examples
         --------
         >>> idx = pd.date_range(start='2019-12-29', freq='D', periods=4)
-        >>> idx.isocalendar
+        >>> idx.isocalendar()
            year  week  day
         0  2019    52    7
         1  2020     1    1
         2  2020     1    2
         3  2020     1    3
-        >>> idx.isocalendar.week
+        >>> idx.isocalendar().week
         0    52
         1     1
         2     1

pandas/core/indexes/accessors.py

@@ -219,7 +219,6 @@ def to_pydatetime(self) -> np.ndarray:
     def freq(self):
         return self._get_values().inferred_freq
 
-    @property
     def isocalendar(self):
         """
         Returns a DataFrame with the year, week, and day calculated according to
@@ -240,16 +239,16 @@ def isocalendar(self):
         Examples
         --------
         >>> ser = pd.to_datetime(pd.Series(["2010-01-01", pd.NaT]))
-        >>> ser.dt.isocalendar
+        >>> ser.dt.isocalendar()
            year  week  day
         0  2009    53     5
         1  <NA>  <NA>  <NA>
-        >>> ser.dt.isocalendar.week
+        >>> ser.dt.isocalendar().week
         0      53
         1    <NA>
         Name: week, dtype: UInt32
         """
-        return self._get_values().isocalendar.set_index(self._parent.index)
+        return self._get_values().isocalendar().set_index(self._parent.index)
 
 
 @delegate_names(

pandas/core/nanops.py

@@ -300,11 +300,8 @@ def _get_values(
         dtype, fill_value=fill_value, fill_value_typ=fill_value_typ
     )
 
-    copy = (mask is not None) and (fill_value is not None)
-
-    if skipna and copy:
+    if skipna and (mask is not None) and (fill_value is not None):
         values = values.copy()
-        assert mask is not None  # for mypy
         if dtype_ok and mask.any():
             np.putmask(values, mask, fill_value)
 

pandas/tests/arrays/categorical/test_analytics.py

@@ -53,40 +53,28 @@ def test_min_max_ordered(self):
     @pytest.mark.parametrize("aggregation", ["min", "max"])
     def test_min_max_ordered_empty(self, categories, expected, aggregation):
         # GH 30227
-        cat = Categorical([], categories=list("ABC"), ordered=True)
+        cat = Categorical([], categories=categories, ordered=True)
 
         agg_func = getattr(cat, aggregation)
         result = agg_func()
         assert result is expected
 
+    @pytest.mark.parametrize(
+        "values, categories",
+        [(["a", "b", "c", np.nan], list("cba")), ([1, 2, 3, np.nan], [3, 2, 1])],
+    )
     @pytest.mark.parametrize("skipna", [True, False])
-    def test_min_max_with_nan(self, skipna):
+    @pytest.mark.parametrize("function", ["min", "max"])
+    def test_min_max_with_nan(self, values, categories, function, skipna):
         # GH 25303
-        cat = Categorical(
-            [np.nan, "b", "c", np.nan], categories=["d", "c", "b", "a"], ordered=True
-        )
-        _min = cat.min(skipna=skipna)
-        _max = cat.max(skipna=skipna)
-
-        if skipna is False:
-            assert np.isnan(_min)
-            assert np.isnan(_max)
-        else:
-            assert _min == "c"
-            assert _max == "b"
-
-        cat = Categorical(
-            [np.nan, 1, 2, np.nan], categories=[5, 4, 3, 2, 1], ordered=True
-        )
-        _min = cat.min(skipna=skipna)
-        _max = cat.max(skipna=skipna)
+        cat = Categorical(values, categories=categories, ordered=True)
+        result = getattr(cat, function)(skipna=skipna)
 
         if skipna is False:
-            assert np.isnan(_min)
-            assert np.isnan(_max)
+            assert result is np.nan
         else:
-            assert _min == 2
-            assert _max == 1
+            expected = categories[0] if function == "min" else categories[2]
+            assert result == expected
 
     @pytest.mark.parametrize("function", ["min", "max"])
     @pytest.mark.parametrize("skipna", [True, False])

pandas/tests/dtypes/test_missing.py

@@ -564,7 +564,7 @@ def test_checknull(self):
         for value in never_na_vals:
             assert not libmissing.checknull(value)
 
-    def checknull_old(self):
+    def test_checknull_old(self):
         for value in na_vals:
             assert libmissing.checknull_old(value)
 

pandas/tests/indexes/multi/test_indexing.py

@@ -605,10 +605,6 @@ def test_get_loc_nan(self, level, nulls_fixture):
         key = ["b", "d"]
         levels[level] = np.array([0, nulls_fixture], dtype=type(nulls_fixture))
         key[level] = nulls_fixture
-
-        if nulls_fixture is pd.NA:
-            pytest.xfail("MultiIndex from pd.NA in np.array broken; see GH 31883")
-
         idx = MultiIndex.from_product(levels)
         assert idx.get_loc(tuple(key)) == 3
 

pandas/tests/reductions/test_reductions.py

@@ -1072,67 +1072,45 @@ class TestCategoricalSeriesReductions:
     #  were moved from a series-specific test file, _not_ that these tests are
     #  intended long-term to be series-specific
 
-    def test_min_max(self):
+    @pytest.mark.parametrize("function", ["min", "max"])
+    def test_min_max_unordered_raises(self, function):
         # unordered cats have no min/max
         cat = Series(Categorical(["a", "b", "c", "d"], ordered=False))
-        with pytest.raises(TypeError):
-            cat.min()
-        with pytest.raises(TypeError):
-            cat.max()
-
-        cat = Series(Categorical(["a", "b", "c", "d"], ordered=True))
-        _min = cat.min()
-        _max = cat.max()
-        assert _min == "a"
-        assert _max == "d"
-
-        cat = Series(
-            Categorical(
-                ["a", "b", "c", "d"], categories=["d", "c", "b", "a"], ordered=True
-            )
-        )
-        _min = cat.min()
-        _max = cat.max()
-        assert _min == "d"
-        assert _max == "a"
-
-        cat = Series(
-            Categorical(
-                [np.nan, "b", "c", np.nan],
-                categories=["d", "c", "b", "a"],
-                ordered=True,
-            )
-        )
-        _min = cat.min()
-        _max = cat.max()
-        assert _min == "c"
-        assert _max == "b"
+        msg = f"Categorical is not ordered for operation {function}"
+        with pytest.raises(TypeError, match=msg):
+            getattr(cat, function)()
 
-        cat = Series(
-            Categorical(
-                [np.nan, 1, 2, np.nan], categories=[5, 4, 3, 2, 1], ordered=True
-            )
-        )
-        _min = cat.min()
-        _max = cat.max()
-        assert _min == 2
-        assert _max == 1
+    @pytest.mark.parametrize(
+        "values, categories",
+        [
+            (list("abc"), list("abc")),
+            (list("abc"), list("cba")),
+            (list("abc") + [np.nan], list("cba")),
+            ([1, 2, 3], [3, 2, 1]),
+            ([1, 2, 3, np.nan], [3, 2, 1]),
+        ],
+    )
+    @pytest.mark.parametrize("function", ["min", "max"])
+    def test_min_max_ordered(self, values, categories, function):
+        # GH 25303
+        cat = Series(Categorical(values, categories=categories, ordered=True))
+        result = getattr(cat, function)(skipna=True)
+        expected = categories[0] if function == "min" else categories[2]
+        assert result == expected
 
+    @pytest.mark.parametrize("function", ["min", "max"])
     @pytest.mark.parametrize("skipna", [True, False])
-    def test_min_max_skipna(self, skipna):
-        # GH 25303
+    def test_min_max_skipna(self, function, skipna):
         cat = Series(
             Categorical(["a", "b", np.nan, "a"], categories=["b", "a"], ordered=True)
         )
-        _min = cat.min(skipna=skipna)
-        _max = cat.max(skipna=skipna)
+        result = getattr(cat, function)(skipna=skipna)
 
         if skipna is True:
-            assert _min == "b"
-            assert _max == "a"
+            expected = "b" if function == "min" else "a"
+            assert result == expected
         else:
-            assert np.isnan(_min)
-            assert np.isnan(_max)
+            assert result is np.nan
 
 
 class TestSeriesMode:

pandas/tests/series/test_datetime_values.py

@@ -49,6 +49,7 @@ def test_dt_namespace_accessor(self):
             "ceil",
             "day_name",
             "month_name",
+            "isocalendar",
         ]
         ok_for_td = TimedeltaIndex._datetimelike_ops
         ok_for_td_methods = [
@@ -678,7 +679,7 @@ def test_setitem_with_different_tz(self):
         ],
     )
     def test_isocalendar(self, input_series, expected_output):
-        result = pd.to_datetime(pd.Series(input_series)).dt.isocalendar
+        result = pd.to_datetime(pd.Series(input_series)).dt.isocalendar()
         expected_frame = pd.DataFrame(
             expected_output, columns=["year", "week", "day"], dtype="UInt32"
         )