Merge branch 'main' into ref-split-pattern

Author: jbrockmendel

ci/azure/posix.yml

@@ -4,40 +4,22 @@ parameters:
 
 jobs:
 - job: ${{ parameters.name }}
+  timeoutInMinutes: 90
   pool:
     vmImage: ${{ parameters.vmImage }}
   strategy:
     matrix:
-      py38_macos_1:
+      py38:
         ENV_FILE: ci/deps/azure-macos-38.yaml
         CONDA_PY: "38"
-        PATTERN: "not slow and not single_cpu"
-        PYTEST_TARGET: "pandas/tests/[a-h]*"
-      py38_macos_2:
-        ENV_FILE: ci/deps/azure-macos-38.yaml
-        CONDA_PY: "38"
-        PATTERN: "not slow and not single_cpu"
-        PYTEST_TARGET: "pandas/tests/[i-z]*"
-      py39_macos_1:
-        ENV_FILE: ci/deps/azure-macos-39.yaml
-        CONDA_PY: "39"
-        PATTERN: "not slow and not single_cpu"
-        PYTEST_TARGET: "pandas/tests/[a-h]*"
-      py39_macos_2:
+
+      py39:
         ENV_FILE: ci/deps/azure-macos-39.yaml
         CONDA_PY: "39"
-        PATTERN: "not slow and not single_cpu"
-        PYTEST_TARGET: "pandas/tests/[i-z]*"
-      py310_macos_1:
-        ENV_FILE: ci/deps/azure-macos-310.yaml
-        CONDA_PY: "310"
-        PATTERN: "not slow and not single_cpu"
-        PYTEST_TARGET: "pandas/tests/[a-h]*"
-      py310_macos_2:
+
+      py310:
         ENV_FILE: ci/deps/azure-macos-310.yaml
         CONDA_PY: "310"
-        PATTERN: "not slow and not single_cpu"
-        PYTEST_TARGET: "pandas/tests/[i-z]*"
 
   steps:
     - script: echo '##vso[task.prependpath]$(HOME)/miniconda3/bin'

doc/source/whatsnew/v1.5.0.rst

@@ -238,6 +238,7 @@ Other Deprecations
 - Deprecated behavior of :meth:`DatetimeIndex.intersection` and :meth:`DatetimeIndex.symmetric_difference` (``union`` behavior was already deprecated in version 1.3.0) with mixed time zones; in a future version both will be cast to UTC instead of object dtype (:issue:`39328`, :issue:`45357`)
 - Deprecated :meth:`DataFrame.iteritems`, :meth:`Series.iteritems`, :meth:`HDFStore.iteritems` in favor of :meth:`DataFrame.items`, :meth:`Series.items`, :meth:`HDFStore.items`  (:issue:`45321`)
 - Deprecated :meth:`Series.is_monotonic` and :meth:`Index.is_monotonic` in favor of :meth:`Series.is_monotonic_increasing` and :meth:`Index.is_monotonic_increasing` (:issue:`45422`, :issue:`21335`)
+- Deprecated behavior of :meth:`DatetimeIndex.astype`, :meth:`TimedeltaIndex.astype`, :meth:`PeriodIndex.astype` when converting to an integer dtype other than ``int64``. In a future version, these will convert to exactly the specified dtype (instead of always ``int64``) and will raise if the conversion overflows (:issue:`45034`)
 - Deprecated the ``__array_wrap__`` method of DataFrame and Series, rely on standard numpy ufuncs instead (:issue:`45451`)
 - Deprecated the behavior of :meth:`Series.fillna` and :meth:`DataFrame.fillna` with ``timedelta64[ns]`` dtype and incompatible fill value; in a future version this will cast to a common dtype (usually object) instead of raising, matching the behavior of other dtypes (:issue:`45746`)
 - Deprecated the ``warn`` parameter in :func:`infer_freq` (:issue:`45947`)

pandas/core/arrays/datetimelike.py

@@ -446,6 +446,36 @@ def astype(self, dtype, copy: bool = True):
             if is_unsigned_integer_dtype(dtype):
                 # Again, we ignore int32 vs. int64
                 values = values.view("uint64")
+                if dtype != np.uint64:
+                    # GH#45034
+                    warnings.warn(
+                        f"The behavior of .astype from {self.dtype} to {dtype} is "
+                        "deprecated. In a future version, this astype will return "
+                        "exactly the specified dtype instead of uint64, and will "
+                        "raise if that conversion overflows.",
+                        FutureWarning,
+                        stacklevel=find_stack_level(),
+                    )
+                elif (self.asi8 < 0).any():
+                    # GH#45034
+                    warnings.warn(
+                        f"The behavior of .astype from {self.dtype} to {dtype} is "
+                        "deprecated. In a future version, this astype will "
+                        "raise if the conversion overflows, as it did in this "
+                        "case with negative int64 values.",
+                        FutureWarning,
+                        stacklevel=find_stack_level(),
+                    )
+            elif dtype != np.int64:
+                # GH#45034
+                warnings.warn(
+                    f"The behavior of .astype from {self.dtype} to {dtype} is "
+                    "deprecated. In a future version, this astype will return "
+                    "exactly the specified dtype instead of int64, and will "
+                    "raise if that conversion overflows.",
+                    FutureWarning,
+                    stacklevel=find_stack_level(),
+                )
 
             if copy:
                 values = values.copy()

pandas/tests/apply/test_str.py

@@ -45,12 +45,11 @@ def test_apply_with_string_funcs(request, float_frame, func, args, kwds, how):
     tm.assert_series_equal(result, expected)
 
 
-def test_with_string_args(datetime_series):
-
-    for arg in ["sum", "mean", "min", "max", "std"]:
-        result = datetime_series.apply(arg)
-        expected = getattr(datetime_series, arg)()
-        assert result == expected
+@pytest.mark.parametrize("arg", ["sum", "mean", "min", "max", "std"])
+def test_with_string_args(datetime_series, arg):
+    result = datetime_series.apply(arg)
+    expected = getattr(datetime_series, arg)()
+    assert result == expected
 
 
 @pytest.mark.parametrize("op", ["mean", "median", "std", "var"])

pandas/tests/arithmetic/test_numeric.py

@@ -5,7 +5,6 @@
 
 from collections import abc
 from decimal import Decimal
-from itertools import combinations
 import operator
 from typing import Any
 
@@ -928,7 +927,6 @@ def test_datetime64_with_index(self):
     # TODO: taken from tests.frame.test_operators, needs cleanup
     def test_frame_operators(self, float_frame):
         frame = float_frame
-        frame2 = pd.DataFrame(float_frame, columns=["D", "C", "B", "A"])
 
         garbage = np.random.random(4)
         colSeries = Series(garbage, index=np.array(frame.columns))
@@ -952,23 +950,27 @@ def test_frame_operators(self, float_frame):
                 else:
                     assert np.isnan(origVal)
 
+    def test_frame_operators_col_align(self, float_frame):
+        frame2 = pd.DataFrame(float_frame, columns=["D", "C", "B", "A"])
         added = frame2 + frame2
         expected = frame2 * 2
         tm.assert_frame_equal(added, expected)
 
+    def test_frame_operators_none_to_nan(self):
         df = pd.DataFrame({"a": ["a", None, "b"]})
         tm.assert_frame_equal(df + df, pd.DataFrame({"a": ["aa", np.nan, "bb"]}))
 
+    @pytest.mark.parametrize("dtype", ("float", "int64"))
+    def test_frame_operators_empty_like(self, dtype):
         # Test for issue #10181
-        for dtype in ("float", "int64"):
-            frames = [
-                pd.DataFrame(dtype=dtype),
-                pd.DataFrame(columns=["A"], dtype=dtype),
-                pd.DataFrame(index=[0], dtype=dtype),
-            ]
-            for df in frames:
-                assert (df + df).equals(df)
-                tm.assert_frame_equal(df + df, df)
+        frames = [
+            pd.DataFrame(dtype=dtype),
+            pd.DataFrame(columns=["A"], dtype=dtype),
+            pd.DataFrame(index=[0], dtype=dtype),
+        ]
+        for df in frames:
+            assert (df + df).equals(df)
+            tm.assert_frame_equal(df + df, df)
 
     @pytest.mark.parametrize(
         "func",
@@ -1164,45 +1166,85 @@ def test_operators_reverse_object(self, op):
 class TestNumericArithmeticUnsorted:
     # Tests in this class have been moved from type-specific test modules
     #  but not yet sorted, parametrized, and de-duplicated
-
-    def check_binop(self, ops, scalars, idxs):
-        for op in ops:
-            for a, b in combinations(idxs, 2):
-                a = a._rename("foo")
-                b = b._rename("bar")
-                result = op(a, b)
-                expected = op(Int64Index(a), Int64Index(b))
-                tm.assert_index_equal(result, expected, exact="equiv")
-            for idx in idxs:
-                for scalar in scalars:
-                    result = op(idx, scalar)
-                    expected = op(Int64Index(idx), scalar)
-                    tm.assert_index_equal(result, expected, exact="equiv")
-
-    def test_binops(self):
-        ops = [
+    @pytest.mark.parametrize(
+        "op",
+        [
             operator.add,
             operator.sub,
             operator.mul,
             operator.floordiv,
             operator.truediv,
-        ]
-        scalars = [-1, 1, 2]
-        idxs = [
+        ],
+    )
+    @pytest.mark.parametrize(
+        "idx1",
+        [
             RangeIndex(0, 10, 1),
             RangeIndex(0, 20, 2),
             RangeIndex(-10, 10, 2),
             RangeIndex(5, -5, -1),
-        ]
-        self.check_binop(ops, scalars, idxs)
+        ],
+    )
+    @pytest.mark.parametrize(
+        "idx2",
+        [
+            RangeIndex(0, 10, 1),
+            RangeIndex(0, 20, 2),
+            RangeIndex(-10, 10, 2),
+            RangeIndex(5, -5, -1),
+        ],
+    )
+    def test_binops_index(self, op, idx1, idx2):
+        idx1 = idx1._rename("foo")
+        idx2 = idx2._rename("bar")
+        result = op(idx1, idx2)
+        expected = op(Int64Index(idx1), Int64Index(idx2))
+        tm.assert_index_equal(result, expected, exact="equiv")
 
-    def test_binops_pow(self):
+    @pytest.mark.parametrize(
+        "op",
+        [
+            operator.add,
+            operator.sub,
+            operator.mul,
+            operator.floordiv,
+            operator.truediv,
+        ],
+    )
+    @pytest.mark.parametrize(
+        "idx",
+        [
+            RangeIndex(0, 10, 1),
+            RangeIndex(0, 20, 2),
+            RangeIndex(-10, 10, 2),
+            RangeIndex(5, -5, -1),
+        ],
+    )
+    @pytest.mark.parametrize("scalar", [-1, 1, 2])
+    def test_binops_index_scalar(self, op, idx, scalar):
+        result = op(idx, scalar)
+        expected = op(Int64Index(idx), scalar)
+        tm.assert_index_equal(result, expected, exact="equiv")
+
+    @pytest.mark.parametrize("idx1", [RangeIndex(0, 10, 1), RangeIndex(0, 20, 2)])
+    @pytest.mark.parametrize("idx2", [RangeIndex(0, 10, 1), RangeIndex(0, 20, 2)])
+    def test_binops_index_pow(self, idx1, idx2):
         # numpy does not allow powers of negative integers so test separately
         # https://github.com/numpy/numpy/pull/8127
-        ops = [pow]
-        scalars = [1, 2]
-        idxs = [RangeIndex(0, 10, 1), RangeIndex(0, 20, 2)]
-        self.check_binop(ops, scalars, idxs)
+        idx1 = idx1._rename("foo")
+        idx2 = idx2._rename("bar")
+        result = pow(idx1, idx2)
+        expected = pow(Int64Index(idx1), Int64Index(idx2))
+        tm.assert_index_equal(result, expected, exact="equiv")
+
+    @pytest.mark.parametrize("idx", [RangeIndex(0, 10, 1), RangeIndex(0, 20, 2)])
+    @pytest.mark.parametrize("scalar", [1, 2])
+    def test_binops_index_scalar_pow(self, idx, scalar):
+        # numpy does not allow powers of negative integers so test separately
+        # https://github.com/numpy/numpy/pull/8127
+        result = pow(idx, scalar)
+        expected = pow(Int64Index(idx), scalar)
+        tm.assert_index_equal(result, expected, exact="equiv")
 
     # TODO: divmod?
     @pytest.mark.parametrize(
@@ -1273,8 +1315,9 @@ def test_numeric_compat2(self):
         expected = Int64Index(idx._values) ** 2
         tm.assert_index_equal(Index(result.values), expected, exact=True)
 
-        # __floordiv__
-        cases_exact = [
+    @pytest.mark.parametrize(
+        "idx, div, expected",
+        [
             (RangeIndex(0, 1000, 2), 2, RangeIndex(0, 500, 1)),
             (RangeIndex(-99, -201, -3), -3, RangeIndex(33, 67, 1)),
             (
@@ -1291,9 +1334,11 @@ def test_numeric_compat2(self):
             (RangeIndex(2, 4, 2), 3, RangeIndex(0, 1, 1)),
             (RangeIndex(-5, -10, -6), 4, RangeIndex(-2, -1, 1)),
             (RangeIndex(-100, -200, 3), 2, RangeIndex(0)),
-        ]
-        for idx, div, expected in cases_exact:
-            tm.assert_index_equal(idx // div, expected, exact=True)
+        ],
+    )
+    def test_numeric_compat2_floordiv(self, idx, div, expected):
+        # __floordiv__
+        tm.assert_index_equal(idx // div, expected, exact=True)
 
     @pytest.mark.parametrize("dtype", [np.int64, np.float64])
     @pytest.mark.parametrize("delta", [1, 0, -1])