Add files using upload-large-folder tool

ckpts/llama-3b/global_step100/bf16_zero_pp_rank_122_mp_rank_00_optim_states.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7e6812571c227fed711e7cad368af9a4c26e6b16ab7341eeda7d2f5939e338cf
+size 41830212

venv/lib/python3.10/site-packages/pandas/tests/construction/test_extract_array.py

@@ -0,0 +1,18 @@
+from pandas import Index
+import pandas._testing as tm
+from pandas.core.construction import extract_array
+
+
+def test_extract_array_rangeindex():
+    ri = Index(range(5))
+
+    expected = ri._values
+    res = extract_array(ri, extract_numpy=True, extract_range=True)
+    tm.assert_numpy_array_equal(res, expected)
+    res = extract_array(ri, extract_numpy=False, extract_range=True)
+    tm.assert_numpy_array_equal(res, expected)
+
+    res = extract_array(ri, extract_numpy=True, extract_range=False)
+    tm.assert_index_equal(res, ri)
+    res = extract_array(ri, extract_numpy=False, extract_range=False)
+    tm.assert_index_equal(res, ri)

venv/lib/python3.10/site-packages/pandas/tests/extension/base/base.py

@@ -0,0 +1,2 @@
+class BaseExtensionTests:
+    pass

venv/lib/python3.10/site-packages/pandas/tests/extension/base/casting.py

@@ -0,0 +1,87 @@
+import numpy as np
+import pytest
+
+import pandas.util._test_decorators as td
+
+import pandas as pd
+import pandas._testing as tm
+from pandas.core.internals.blocks import NumpyBlock
+
+
+class BaseCastingTests:
+    """Casting to and from ExtensionDtypes"""
+
+    def test_astype_object_series(self, all_data):
+        ser = pd.Series(all_data, name="A")
+        result = ser.astype(object)
+        assert result.dtype == np.dtype(object)
+        if hasattr(result._mgr, "blocks"):
+            blk = result._mgr.blocks[0]
+            assert isinstance(blk, NumpyBlock)
+            assert blk.is_object
+        assert isinstance(result._mgr.array, np.ndarray)
+        assert result._mgr.array.dtype == np.dtype(object)
+
+    def test_astype_object_frame(self, all_data):
+        df = pd.DataFrame({"A": all_data})
+
+        result = df.astype(object)
+        if hasattr(result._mgr, "blocks"):
+            blk = result._mgr.blocks[0]
+            assert isinstance(blk, NumpyBlock), type(blk)
+            assert blk.is_object
+        assert isinstance(result._mgr.arrays[0], np.ndarray)
+        assert result._mgr.arrays[0].dtype == np.dtype(object)
+
+        # check that we can compare the dtypes
+        comp = result.dtypes == df.dtypes
+        assert not comp.any()
+
+    def test_tolist(self, data):
+        result = pd.Series(data).tolist()
+        expected = list(data)
+        assert result == expected
+
+    def test_astype_str(self, data):
+        result = pd.Series(data[:5]).astype(str)
+        expected = pd.Series([str(x) for x in data[:5]], dtype=str)
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "nullable_string_dtype",
+        [
+            "string[python]",
+            pytest.param("string[pyarrow]", marks=td.skip_if_no("pyarrow")),
+        ],
+    )
+    def test_astype_string(self, data, nullable_string_dtype):
+        # GH-33465, GH#45326 as of 2.0 we decode bytes instead of calling str(obj)
+        result = pd.Series(data[:5]).astype(nullable_string_dtype)
+        expected = pd.Series(
+            [str(x) if not isinstance(x, bytes) else x.decode() for x in data[:5]],
+            dtype=nullable_string_dtype,
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_to_numpy(self, data):
+        expected = np.asarray(data)
+
+        result = data.to_numpy()
+        tm.assert_equal(result, expected)
+
+        result = pd.Series(data).to_numpy()
+        tm.assert_equal(result, expected)
+
+    def test_astype_empty_dataframe(self, dtype):
+        # https://github.com/pandas-dev/pandas/issues/33113
+        df = pd.DataFrame()
+        result = df.astype(dtype)
+        tm.assert_frame_equal(result, df)
+
+    @pytest.mark.parametrize("copy", [True, False])
+    def test_astype_own_type(self, data, copy):
+        # ensure that astype returns the original object for equal dtype and copy=False
+        # https://github.com/pandas-dev/pandas/issues/28488
+        result = data.astype(data.dtype, copy=copy)
+        assert (result is data) is (not copy)
+        tm.assert_extension_array_equal(result, data)

venv/lib/python3.10/site-packages/pandas/tests/extension/base/groupby.py

@@ -0,0 +1,174 @@
+import re
+
+import pytest
+
+from pandas.core.dtypes.common import (
+    is_bool_dtype,
+    is_numeric_dtype,
+    is_object_dtype,
+    is_string_dtype,
+)
+
+import pandas as pd
+import pandas._testing as tm
+
+
+@pytest.mark.filterwarnings(
+    "ignore:The default of observed=False is deprecated:FutureWarning"
+)
+class BaseGroupbyTests:
+    """Groupby-specific tests."""
+
+    def test_grouping_grouper(self, data_for_grouping):
+        df = pd.DataFrame(
+            {
+                "A": pd.Series(
+                    ["B", "B", None, None, "A", "A", "B", "C"], dtype=object
+                ),
+                "B": data_for_grouping,
+            }
+        )
+        gr1 = df.groupby("A")._grouper.groupings[0]
+        gr2 = df.groupby("B")._grouper.groupings[0]
+
+        tm.assert_numpy_array_equal(gr1.grouping_vector, df.A.values)
+        tm.assert_extension_array_equal(gr2.grouping_vector, data_for_grouping)
+
+    @pytest.mark.parametrize("as_index", [True, False])
+    def test_groupby_extension_agg(self, as_index, data_for_grouping):
+        df = pd.DataFrame({"A": [1, 1, 2, 2, 3, 3, 1, 4], "B": data_for_grouping})
+
+        is_bool = data_for_grouping.dtype._is_boolean
+        if is_bool:
+            # only 2 unique values, and the final entry has c==b
+            #  (see data_for_grouping docstring)
+            df = df.iloc[:-1]
+
+        result = df.groupby("B", as_index=as_index).A.mean()
+        _, uniques = pd.factorize(data_for_grouping, sort=True)
+
+        exp_vals = [3.0, 1.0, 4.0]
+        if is_bool:
+            exp_vals = exp_vals[:-1]
+        if as_index:
+            index = pd.Index(uniques, name="B")
+            expected = pd.Series(exp_vals, index=index, name="A")
+            tm.assert_series_equal(result, expected)
+        else:
+            expected = pd.DataFrame({"B": uniques, "A": exp_vals})
+            tm.assert_frame_equal(result, expected)
+
+    def test_groupby_agg_extension(self, data_for_grouping):
+        # GH#38980 groupby agg on extension type fails for non-numeric types
+        df = pd.DataFrame({"A": [1, 1, 2, 2, 3, 3, 1, 4], "B": data_for_grouping})
+
+        expected = df.iloc[[0, 2, 4, 7]]
+        expected = expected.set_index("A")
+
+        result = df.groupby("A").agg({"B": "first"})
+        tm.assert_frame_equal(result, expected)
+
+        result = df.groupby("A").agg("first")
+        tm.assert_frame_equal(result, expected)
+
+        result = df.groupby("A").first()
+        tm.assert_frame_equal(result, expected)
+
+    def test_groupby_extension_no_sort(self, data_for_grouping):
+        df = pd.DataFrame({"A": [1, 1, 2, 2, 3, 3, 1, 4], "B": data_for_grouping})
+
+        is_bool = data_for_grouping.dtype._is_boolean
+        if is_bool:
+            # only 2 unique values, and the final entry has c==b
+            #  (see data_for_grouping docstring)
+            df = df.iloc[:-1]
+
+        result = df.groupby("B", sort=False).A.mean()
+        _, index = pd.factorize(data_for_grouping, sort=False)
+
+        index = pd.Index(index, name="B")
+        exp_vals = [1.0, 3.0, 4.0]
+        if is_bool:
+            exp_vals = exp_vals[:-1]
+        expected = pd.Series(exp_vals, index=index, name="A")
+        tm.assert_series_equal(result, expected)
+
+    def test_groupby_extension_transform(self, data_for_grouping):
+        is_bool = data_for_grouping.dtype._is_boolean
+
+        valid = data_for_grouping[~data_for_grouping.isna()]
+        df = pd.DataFrame({"A": [1, 1, 3, 3, 1, 4], "B": valid})
+        is_bool = data_for_grouping.dtype._is_boolean
+        if is_bool:
+            # only 2 unique values, and the final entry has c==b
+            #  (see data_for_grouping docstring)
+            df = df.iloc[:-1]
+
+        result = df.groupby("B").A.transform(len)
+        expected = pd.Series([3, 3, 2, 2, 3, 1], name="A")
+        if is_bool:
+            expected = expected[:-1]
+
+        tm.assert_series_equal(result, expected)
+
+    def test_groupby_extension_apply(self, data_for_grouping, groupby_apply_op):
+        df = pd.DataFrame({"A": [1, 1, 2, 2, 3, 3, 1, 4], "B": data_for_grouping})
+        msg = "DataFrameGroupBy.apply operated on the grouping columns"
+        with tm.assert_produces_warning(DeprecationWarning, match=msg):
+            df.groupby("B", group_keys=False, observed=False).apply(groupby_apply_op)
+        df.groupby("B", group_keys=False, observed=False).A.apply(groupby_apply_op)
+        msg = "DataFrameGroupBy.apply operated on the grouping columns"
+        with tm.assert_produces_warning(DeprecationWarning, match=msg):
+            df.groupby("A", group_keys=False, observed=False).apply(groupby_apply_op)
+        df.groupby("A", group_keys=False, observed=False).B.apply(groupby_apply_op)
+
+    def test_groupby_apply_identity(self, data_for_grouping):
+        df = pd.DataFrame({"A": [1, 1, 2, 2, 3, 3, 1, 4], "B": data_for_grouping})
+        result = df.groupby("A").B.apply(lambda x: x.array)
+        expected = pd.Series(
+            [
+                df.B.iloc[[0, 1, 6]].array,
+                df.B.iloc[[2, 3]].array,
+                df.B.iloc[[4, 5]].array,
+                df.B.iloc[[7]].array,
+            ],
+            index=pd.Index([1, 2, 3, 4], name="A"),
+            name="B",
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_in_numeric_groupby(self, data_for_grouping):
+        df = pd.DataFrame(
+            {
+                "A": [1, 1, 2, 2, 3, 3, 1, 4],
+                "B": data_for_grouping,
+                "C": [1, 1, 1, 1, 1, 1, 1, 1],
+            }
+        )
+
+        dtype = data_for_grouping.dtype
+        if (
+            is_numeric_dtype(dtype)
+            or is_bool_dtype(dtype)
+            or dtype.name == "decimal"
+            or is_string_dtype(dtype)
+            or is_object_dtype(dtype)
+            or dtype.kind == "m"  # in particular duration[*][pyarrow]
+        ):
+            expected = pd.Index(["B", "C"])
+            result = df.groupby("A").sum().columns
+        else:
+            expected = pd.Index(["C"])
+
+            msg = "|".join(
+                [
+                    # period/datetime
+                    "does not support sum operations",
+                    # all others
+                    re.escape(f"agg function failed [how->sum,dtype->{dtype}"),
+                ]
+            )
+            with pytest.raises(TypeError, match=msg):
+                df.groupby("A").sum()
+            result = df.groupby("A").sum(numeric_only=True).columns
+        tm.assert_index_equal(result, expected)

venv/lib/python3.10/site-packages/pandas/tests/extension/base/index.py

@@ -0,0 +1,19 @@
+"""
+Tests for Indexes backed by arbitrary ExtensionArrays.
+"""
+import pandas as pd
+
+
+class BaseIndexTests:
+    """Tests for Index object backed by an ExtensionArray"""
+
+    def test_index_from_array(self, data):
+        idx = pd.Index(data)
+        assert data.dtype == idx.dtype
+
+    def test_index_from_listlike_with_dtype(self, data):
+        idx = pd.Index(data, dtype=data.dtype)
+        assert idx.dtype == data.dtype
+
+        idx = pd.Index(list(data), dtype=data.dtype)
+        assert idx.dtype == data.dtype

venv/lib/python3.10/site-packages/pandas/tests/extension/base/io.py

@@ -0,0 +1,39 @@
+from io import StringIO
+
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+from pandas.core.arrays import ExtensionArray
+
+
+class BaseParsingTests:
+    @pytest.mark.parametrize("engine", ["c", "python"])
+    def test_EA_types(self, engine, data, request):
+        if isinstance(data.dtype, pd.CategoricalDtype):
+            # in parsers.pyx _convert_with_dtype there is special-casing for
+            #  Categorical that pre-empts _from_sequence_of_strings
+            pass
+        elif isinstance(data.dtype, pd.core.dtypes.dtypes.NumpyEADtype):
+            # These get unwrapped internally so are treated as numpy dtypes
+            #  in the parsers.pyx code
+            pass
+        elif (
+            type(data)._from_sequence_of_strings.__func__
+            is ExtensionArray._from_sequence_of_strings.__func__
+        ):
+            # i.e. the EA hasn't overridden _from_sequence_of_strings
+            mark = pytest.mark.xfail(
+                reason="_from_sequence_of_strings not implemented",
+                raises=NotImplementedError,
+            )
+            request.node.add_marker(mark)
+
+        df = pd.DataFrame({"with_dtype": pd.Series(data, dtype=str(data.dtype))})
+        csv_output = df.to_csv(index=False, na_rep=np.nan)
+        result = pd.read_csv(
+            StringIO(csv_output), dtype={"with_dtype": str(data.dtype)}, engine=engine
+        )
+        expected = df
+        tm.assert_frame_equal(result, expected)

venv/lib/python3.10/site-packages/pandas/tests/extension/base/missing.py

@@ -0,0 +1,188 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+
+
+class BaseMissingTests:
+    def test_isna(self, data_missing):
+        expected = np.array([True, False])
+
+        result = pd.isna(data_missing)
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = pd.Series(data_missing).isna()
+        expected = pd.Series(expected)
+        tm.assert_series_equal(result, expected)
+
+        # GH 21189
+        result = pd.Series(data_missing).drop([0, 1]).isna()
+        expected = pd.Series([], dtype=bool)
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("na_func", ["isna", "notna"])
+    def test_isna_returns_copy(self, data_missing, na_func):
+        result = pd.Series(data_missing)
+        expected = result.copy()
+        mask = getattr(result, na_func)()
+        if isinstance(mask.dtype, pd.SparseDtype):
+            mask = np.array(mask)
+
+        mask[:] = True
+        tm.assert_series_equal(result, expected)
+
+    def test_dropna_array(self, data_missing):
+        result = data_missing.dropna()
+        expected = data_missing[[1]]
+        tm.assert_extension_array_equal(result, expected)
+
+    def test_dropna_series(self, data_missing):
+        ser = pd.Series(data_missing)
+        result = ser.dropna()
+        expected = ser.iloc[[1]]
+        tm.assert_series_equal(result, expected)
+
+    def test_dropna_frame(self, data_missing):
+        df = pd.DataFrame({"A": data_missing}, columns=pd.Index(["A"], dtype=object))
+
+        # defaults
+        result = df.dropna()
+        expected = df.iloc[[1]]
+        tm.assert_frame_equal(result, expected)
+
+        # axis = 1
+        result = df.dropna(axis="columns")
+        expected = pd.DataFrame(index=pd.RangeIndex(2), columns=pd.Index([]))
+        tm.assert_frame_equal(result, expected)
+
+        # multiple
+        df = pd.DataFrame({"A": data_missing, "B": [1, np.nan]})
+        result = df.dropna()
+        expected = df.iloc[:0]
+        tm.assert_frame_equal(result, expected)
+
+    def test_fillna_scalar(self, data_missing):
+        valid = data_missing[1]
+        result = data_missing.fillna(valid)
+        expected = data_missing.fillna(valid)
+        tm.assert_extension_array_equal(result, expected)
+
+    @pytest.mark.filterwarnings(
+        "ignore:Series.fillna with 'method' is deprecated:FutureWarning"
+    )
+    def test_fillna_limit_pad(self, data_missing):
+        arr = data_missing.take([1, 0, 0, 0, 1])
+        result = pd.Series(arr).ffill(limit=2)
+        expected = pd.Series(data_missing.take([1, 1, 1, 0, 1]))
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "limit_area, input_ilocs, expected_ilocs",
+        [
+            ("outside", [1, 0, 0, 0, 1], [1, 0, 0, 0, 1]),
+            ("outside", [1, 0, 1, 0, 1], [1, 0, 1, 0, 1]),
+            ("outside", [0, 1, 1, 1, 0], [0, 1, 1, 1, 1]),
+            ("outside", [0, 1, 0, 1, 0], [0, 1, 0, 1, 1]),
+            ("inside", [1, 0, 0, 0, 1], [1, 1, 1, 1, 1]),
+            ("inside", [1, 0, 1, 0, 1], [1, 1, 1, 1, 1]),
+            ("inside", [0, 1, 1, 1, 0], [0, 1, 1, 1, 0]),
+            ("inside", [0, 1, 0, 1, 0], [0, 1, 1, 1, 0]),
+        ],
+    )
+    def test_ffill_limit_area(
+        self, data_missing, limit_area, input_ilocs, expected_ilocs
+    ):
+        # GH#56616
+        arr = data_missing.take(input_ilocs)
+        result = pd.Series(arr).ffill(limit_area=limit_area)
+        expected = pd.Series(data_missing.take(expected_ilocs))
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.filterwarnings(
+        "ignore:Series.fillna with 'method' is deprecated:FutureWarning"
+    )
+    def test_fillna_limit_backfill(self, data_missing):
+        arr = data_missing.take([1, 0, 0, 0, 1])
+        result = pd.Series(arr).fillna(method="backfill", limit=2)
+        expected = pd.Series(data_missing.take([1, 0, 1, 1, 1]))
+        tm.assert_series_equal(result, expected)
+
+    def test_fillna_no_op_returns_copy(self, data):
+        data = data[~data.isna()]
+
+        valid = data[0]
+        result = data.fillna(valid)
+        assert result is not data
+        tm.assert_extension_array_equal(result, data)
+
+        result = data._pad_or_backfill(method="backfill")
+        assert result is not data
+        tm.assert_extension_array_equal(result, data)
+
+    def test_fillna_series(self, data_missing):
+        fill_value = data_missing[1]
+        ser = pd.Series(data_missing)
+
+        result = ser.fillna(fill_value)
+        expected = pd.Series(
+            data_missing._from_sequence(
+                [fill_value, fill_value], dtype=data_missing.dtype
+            )
+        )
+        tm.assert_series_equal(result, expected)
+
+        # Fill with a series
+        result = ser.fillna(expected)
+        tm.assert_series_equal(result, expected)
+
+        # Fill with a series not affecting the missing values
+        result = ser.fillna(ser)
+        tm.assert_series_equal(result, ser)
+
+    def test_fillna_series_method(self, data_missing, fillna_method):
+        fill_value = data_missing[1]
+
+        if fillna_method == "ffill":
+            data_missing = data_missing[::-1]
+
+        result = getattr(pd.Series(data_missing), fillna_method)()
+        expected = pd.Series(
+            data_missing._from_sequence(
+                [fill_value, fill_value], dtype=data_missing.dtype
+            )
+        )
+
+        tm.assert_series_equal(result, expected)
+
+    def test_fillna_frame(self, data_missing):
+        fill_value = data_missing[1]
+
+        result = pd.DataFrame({"A": data_missing, "B": [1, 2]}).fillna(fill_value)
+
+        expected = pd.DataFrame(
+            {
+                "A": data_missing._from_sequence(
+                    [fill_value, fill_value], dtype=data_missing.dtype
+                ),
+                "B": [1, 2],
+            }
+        )
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_fillna_fill_other(self, data):
+        result = pd.DataFrame({"A": data, "B": [np.nan] * len(data)}).fillna({"B": 0.0})
+
+        expected = pd.DataFrame({"A": data, "B": [0.0] * len(result)})
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_use_inf_as_na_no_effect(self, data_missing):
+        ser = pd.Series(data_missing)
+        expected = ser.isna()
+        msg = "use_inf_as_na option is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            with pd.option_context("mode.use_inf_as_na", True):
+                result = ser.isna()
+        tm.assert_series_equal(result, expected)

venv/lib/python3.10/site-packages/pandas/tests/extension/base/reshaping.py

@@ -0,0 +1,379 @@
+import itertools
+
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+from pandas.api.extensions import ExtensionArray
+from pandas.core.internals.blocks import EABackedBlock
+
+
+class BaseReshapingTests:
+    """Tests for reshaping and concatenation."""
+
+    @pytest.mark.parametrize("in_frame", [True, False])
+    def test_concat(self, data, in_frame):
+        wrapped = pd.Series(data)
+        if in_frame:
+            wrapped = pd.DataFrame(wrapped)
+        result = pd.concat([wrapped, wrapped], ignore_index=True)
+
+        assert len(result) == len(data) * 2
+
+        if in_frame:
+            dtype = result.dtypes[0]
+        else:
+            dtype = result.dtype
+
+        assert dtype == data.dtype
+        if hasattr(result._mgr, "blocks"):
+            assert isinstance(result._mgr.blocks[0], EABackedBlock)
+        assert isinstance(result._mgr.arrays[0], ExtensionArray)
+
+    @pytest.mark.parametrize("in_frame", [True, False])
+    def test_concat_all_na_block(self, data_missing, in_frame):
+        valid_block = pd.Series(data_missing.take([1, 1]), index=[0, 1])
+        na_block = pd.Series(data_missing.take([0, 0]), index=[2, 3])
+        if in_frame:
+            valid_block = pd.DataFrame({"a": valid_block})
+            na_block = pd.DataFrame({"a": na_block})
+        result = pd.concat([valid_block, na_block])
+        if in_frame:
+            expected = pd.DataFrame({"a": data_missing.take([1, 1, 0, 0])})
+            tm.assert_frame_equal(result, expected)
+        else:
+            expected = pd.Series(data_missing.take([1, 1, 0, 0]))
+            tm.assert_series_equal(result, expected)
+
+    def test_concat_mixed_dtypes(self, data):
+        # https://github.com/pandas-dev/pandas/issues/20762
+        df1 = pd.DataFrame({"A": data[:3]})
+        df2 = pd.DataFrame({"A": [1, 2, 3]})
+        df3 = pd.DataFrame({"A": ["a", "b", "c"]}).astype("category")
+        dfs = [df1, df2, df3]
+
+        # dataframes
+        result = pd.concat(dfs)
+        expected = pd.concat([x.astype(object) for x in dfs])
+        tm.assert_frame_equal(result, expected)
+
+        # series
+        result = pd.concat([x["A"] for x in dfs])
+        expected = pd.concat([x["A"].astype(object) for x in dfs])
+        tm.assert_series_equal(result, expected)
+
+        # simple test for just EA and one other
+        result = pd.concat([df1, df2.astype(object)])
+        expected = pd.concat([df1.astype("object"), df2.astype("object")])
+        tm.assert_frame_equal(result, expected)
+
+        result = pd.concat([df1["A"], df2["A"].astype(object)])
+        expected = pd.concat([df1["A"].astype("object"), df2["A"].astype("object")])
+        tm.assert_series_equal(result, expected)
+
+    def test_concat_columns(self, data, na_value):
+        df1 = pd.DataFrame({"A": data[:3]})
+        df2 = pd.DataFrame({"B": [1, 2, 3]})
+
+        expected = pd.DataFrame({"A": data[:3], "B": [1, 2, 3]})
+        result = pd.concat([df1, df2], axis=1)
+        tm.assert_frame_equal(result, expected)
+        result = pd.concat([df1["A"], df2["B"]], axis=1)
+        tm.assert_frame_equal(result, expected)
+
+        # non-aligned
+        df2 = pd.DataFrame({"B": [1, 2, 3]}, index=[1, 2, 3])
+        expected = pd.DataFrame(
+            {
+                "A": data._from_sequence(list(data[:3]) + [na_value], dtype=data.dtype),
+                "B": [np.nan, 1, 2, 3],
+            }
+        )
+
+        result = pd.concat([df1, df2], axis=1)
+        tm.assert_frame_equal(result, expected)
+        result = pd.concat([df1["A"], df2["B"]], axis=1)
+        tm.assert_frame_equal(result, expected)
+
+    def test_concat_extension_arrays_copy_false(self, data, na_value):
+        # GH 20756
+        df1 = pd.DataFrame({"A": data[:3]})
+        df2 = pd.DataFrame({"B": data[3:7]})
+        expected = pd.DataFrame(
+            {
+                "A": data._from_sequence(list(data[:3]) + [na_value], dtype=data.dtype),
+                "B": data[3:7],
+            }
+        )
+        result = pd.concat([df1, df2], axis=1, copy=False)
+        tm.assert_frame_equal(result, expected)
+
+    def test_concat_with_reindex(self, data):
+        # GH-33027
+        a = pd.DataFrame({"a": data[:5]})
+        b = pd.DataFrame({"b": data[:5]})
+        result = pd.concat([a, b], ignore_index=True)
+        expected = pd.DataFrame(
+            {
+                "a": data.take(list(range(5)) + ([-1] * 5), allow_fill=True),
+                "b": data.take(([-1] * 5) + list(range(5)), allow_fill=True),
+            }
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_align(self, data, na_value):
+        a = data[:3]
+        b = data[2:5]
+        r1, r2 = pd.Series(a).align(pd.Series(b, index=[1, 2, 3]))
+
+        # Assumes that the ctor can take a list of scalars of the type
+        e1 = pd.Series(data._from_sequence(list(a) + [na_value], dtype=data.dtype))
+        e2 = pd.Series(data._from_sequence([na_value] + list(b), dtype=data.dtype))
+        tm.assert_series_equal(r1, e1)
+        tm.assert_series_equal(r2, e2)
+
+    def test_align_frame(self, data, na_value):
+        a = data[:3]
+        b = data[2:5]
+        r1, r2 = pd.DataFrame({"A": a}).align(pd.DataFrame({"A": b}, index=[1, 2, 3]))
+
+        # Assumes that the ctor can take a list of scalars of the type
+        e1 = pd.DataFrame(
+            {"A": data._from_sequence(list(a) + [na_value], dtype=data.dtype)}
+        )
+        e2 = pd.DataFrame(
+            {"A": data._from_sequence([na_value] + list(b), dtype=data.dtype)}
+        )
+        tm.assert_frame_equal(r1, e1)
+        tm.assert_frame_equal(r2, e2)
+
+    def test_align_series_frame(self, data, na_value):
+        # https://github.com/pandas-dev/pandas/issues/20576
+        ser = pd.Series(data, name="a")
+        df = pd.DataFrame({"col": np.arange(len(ser) + 1)})
+        r1, r2 = ser.align(df)
+
+        e1 = pd.Series(
+            data._from_sequence(list(data) + [na_value], dtype=data.dtype),
+            name=ser.name,
+        )
+
+        tm.assert_series_equal(r1, e1)
+        tm.assert_frame_equal(r2, df)
+
+    def test_set_frame_expand_regular_with_extension(self, data):
+        df = pd.DataFrame({"A": [1] * len(data)})
+        df["B"] = data
+        expected = pd.DataFrame({"A": [1] * len(data), "B": data})
+        tm.assert_frame_equal(df, expected)
+
+    def test_set_frame_expand_extension_with_regular(self, data):
+        df = pd.DataFrame({"A": data})
+        df["B"] = [1] * len(data)
+        expected = pd.DataFrame({"A": data, "B": [1] * len(data)})
+        tm.assert_frame_equal(df, expected)
+
+    def test_set_frame_overwrite_object(self, data):
+        # https://github.com/pandas-dev/pandas/issues/20555
+        df = pd.DataFrame({"A": [1] * len(data)}, dtype=object)
+        df["A"] = data
+        assert df.dtypes["A"] == data.dtype
+
+    def test_merge(self, data, na_value):
+        # GH-20743
+        df1 = pd.DataFrame({"ext": data[:3], "int1": [1, 2, 3], "key": [0, 1, 2]})
+        df2 = pd.DataFrame({"int2": [1, 2, 3, 4], "key": [0, 0, 1, 3]})
+
+        res = pd.merge(df1, df2)
+        exp = pd.DataFrame(
+            {
+                "int1": [1, 1, 2],
+                "int2": [1, 2, 3],
+                "key": [0, 0, 1],
+                "ext": data._from_sequence(
+                    [data[0], data[0], data[1]], dtype=data.dtype
+                ),
+            }
+        )
+        tm.assert_frame_equal(res, exp[["ext", "int1", "key", "int2"]])
+
+        res = pd.merge(df1, df2, how="outer")
+        exp = pd.DataFrame(
+            {
+                "int1": [1, 1, 2, 3, np.nan],
+                "int2": [1, 2, 3, np.nan, 4],
+                "key": [0, 0, 1, 2, 3],
+                "ext": data._from_sequence(
+                    [data[0], data[0], data[1], data[2], na_value], dtype=data.dtype
+                ),
+            }
+        )
+        tm.assert_frame_equal(res, exp[["ext", "int1", "key", "int2"]])
+
+    def test_merge_on_extension_array(self, data):
+        # GH 23020
+        a, b = data[:2]
+        key = type(data)._from_sequence([a, b], dtype=data.dtype)
+
+        df = pd.DataFrame({"key": key, "val": [1, 2]})
+        result = pd.merge(df, df, on="key")
+        expected = pd.DataFrame({"key": key, "val_x": [1, 2], "val_y": [1, 2]})
+        tm.assert_frame_equal(result, expected)
+
+        # order
+        result = pd.merge(df.iloc[[1, 0]], df, on="key")
+        expected = expected.iloc[[1, 0]].reset_index(drop=True)
+        tm.assert_frame_equal(result, expected)
+
+    def test_merge_on_extension_array_duplicates(self, data):
+        # GH 23020
+        a, b = data[:2]
+        key = type(data)._from_sequence([a, b, a], dtype=data.dtype)
+        df1 = pd.DataFrame({"key": key, "val": [1, 2, 3]})
+        df2 = pd.DataFrame({"key": key, "val": [1, 2, 3]})
+
+        result = pd.merge(df1, df2, on="key")
+        expected = pd.DataFrame(
+            {
+                "key": key.take([0, 0, 1, 2, 2]),
+                "val_x": [1, 1, 2, 3, 3],
+                "val_y": [1, 3, 2, 1, 3],
+            }
+        )
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.filterwarnings(
+        "ignore:The previous implementation of stack is deprecated"
+    )
+    @pytest.mark.parametrize(
+        "columns",
+        [
+            ["A", "B"],
+            pd.MultiIndex.from_tuples(
+                [("A", "a"), ("A", "b")], names=["outer", "inner"]
+            ),
+        ],
+    )
+    @pytest.mark.parametrize("future_stack", [True, False])
+    def test_stack(self, data, columns, future_stack):
+        df = pd.DataFrame({"A": data[:5], "B": data[:5]})
+        df.columns = columns
+        result = df.stack(future_stack=future_stack)
+        expected = df.astype(object).stack(future_stack=future_stack)
+        # we need a second astype(object), in case the constructor inferred
+        # object -> specialized, as is done for period.
+        expected = expected.astype(object)
+
+        if isinstance(expected, pd.Series):
+            assert result.dtype == df.iloc[:, 0].dtype
+        else:
+            assert all(result.dtypes == df.iloc[:, 0].dtype)
+
+        result = result.astype(object)
+        tm.assert_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "index",
+        [
+            # Two levels, uniform.
+            pd.MultiIndex.from_product(([["A", "B"], ["a", "b"]]), names=["a", "b"]),
+            # non-uniform
+            pd.MultiIndex.from_tuples([("A", "a"), ("A", "b"), ("B", "b")]),
+            # three levels, non-uniform
+            pd.MultiIndex.from_product([("A", "B"), ("a", "b", "c"), (0, 1, 2)]),
+            pd.MultiIndex.from_tuples(
+                [
+                    ("A", "a", 1),
+                    ("A", "b", 0),
+                    ("A", "a", 0),
+                    ("B", "a", 0),
+                    ("B", "c", 1),
+                ]
+            ),
+        ],
+    )
+    @pytest.mark.parametrize("obj", ["series", "frame"])
+    def test_unstack(self, data, index, obj):
+        data = data[: len(index)]
+        if obj == "series":
+            ser = pd.Series(data, index=index)
+        else:
+            ser = pd.DataFrame({"A": data, "B": data}, index=index)
+
+        n = index.nlevels
+        levels = list(range(n))
+        # [0, 1, 2]
+        # [(0,), (1,), (2,), (0, 1), (0, 2), (1, 0), (1, 2), (2, 0), (2, 1)]
+        combinations = itertools.chain.from_iterable(
+            itertools.permutations(levels, i) for i in range(1, n)
+        )
+
+        for level in combinations:
+            result = ser.unstack(level=level)
+            assert all(
+                isinstance(result[col].array, type(data)) for col in result.columns
+            )
+
+            if obj == "series":
+                # We should get the same result with to_frame+unstack+droplevel
+                df = ser.to_frame()
+
+                alt = df.unstack(level=level).droplevel(0, axis=1)
+                tm.assert_frame_equal(result, alt)
+
+            obj_ser = ser.astype(object)
+
+            expected = obj_ser.unstack(level=level, fill_value=data.dtype.na_value)
+            if obj == "series":
+                assert (expected.dtypes == object).all()
+
+            result = result.astype(object)
+            tm.assert_frame_equal(result, expected)
+
+    def test_ravel(self, data):
+        # as long as EA is 1D-only, ravel is a no-op
+        result = data.ravel()
+        assert type(result) == type(data)
+
+        if data.dtype._is_immutable:
+            pytest.skip(f"test_ravel assumes mutability and {data.dtype} is immutable")
+
+        # Check that we have a view, not a copy
+        result[0] = result[1]
+        assert data[0] == data[1]
+
+    def test_transpose(self, data):
+        result = data.transpose()
+        assert type(result) == type(data)
+
+        # check we get a new object
+        assert result is not data
+
+        # If we ever _did_ support 2D, shape should be reversed
+        assert result.shape == data.shape[::-1]
+
+        if data.dtype._is_immutable:
+            pytest.skip(
+                f"test_transpose assumes mutability and {data.dtype} is immutable"
+            )
+
+        # Check that we have a view, not a copy
+        result[0] = result[1]
+        assert data[0] == data[1]
+
+    def test_transpose_frame(self, data):
+        df = pd.DataFrame({"A": data[:4], "B": data[:4]}, index=["a", "b", "c", "d"])
+        result = df.T
+        expected = pd.DataFrame(
+            {
+                "a": type(data)._from_sequence([data[0]] * 2, dtype=data.dtype),
+                "b": type(data)._from_sequence([data[1]] * 2, dtype=data.dtype),
+                "c": type(data)._from_sequence([data[2]] * 2, dtype=data.dtype),
+                "d": type(data)._from_sequence([data[3]] * 2, dtype=data.dtype),
+            },
+            index=["A", "B"],
+        )
+        tm.assert_frame_equal(result, expected)
+        tm.assert_frame_equal(np.transpose(np.transpose(df)), df)
+        tm.assert_frame_equal(np.transpose(np.transpose(df[["A"]])), df[["A"]])

venv/lib/python3.10/site-packages/pandas/tests/generic/test_duplicate_labels.py

@@ -0,0 +1,413 @@
+"""Tests dealing with the NDFrame.allows_duplicates."""
+import operator
+
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+
+not_implemented = pytest.mark.xfail(reason="Not implemented.")
+
+# ----------------------------------------------------------------------------
+# Preservation
+
+
+class TestPreserves:
+    @pytest.mark.parametrize(
+        "cls, data",
+        [
+            (pd.Series, np.array([])),
+            (pd.Series, [1, 2]),
+            (pd.DataFrame, {}),
+            (pd.DataFrame, {"A": [1, 2]}),
+        ],
+    )
+    def test_construction_ok(self, cls, data):
+        result = cls(data)
+        assert result.flags.allows_duplicate_labels is True
+
+        result = cls(data).set_flags(allows_duplicate_labels=False)
+        assert result.flags.allows_duplicate_labels is False
+
+    @pytest.mark.parametrize(
+        "func",
+        [
+            operator.itemgetter(["a"]),
+            operator.methodcaller("add", 1),
+            operator.methodcaller("rename", str.upper),
+            operator.methodcaller("rename", "name"),
+            operator.methodcaller("abs"),
+            np.abs,
+        ],
+    )
+    def test_preserved_series(self, func):
+        s = pd.Series([0, 1], index=["a", "b"]).set_flags(allows_duplicate_labels=False)
+        assert func(s).flags.allows_duplicate_labels is False
+
+    @pytest.mark.parametrize(
+        "other", [pd.Series(0, index=["a", "b", "c"]), pd.Series(0, index=["a", "b"])]
+    )
+    # TODO: frame
+    @not_implemented
+    def test_align(self, other):
+        s = pd.Series([0, 1], index=["a", "b"]).set_flags(allows_duplicate_labels=False)
+        a, b = s.align(other)
+        assert a.flags.allows_duplicate_labels is False
+        assert b.flags.allows_duplicate_labels is False
+
+    def test_preserved_frame(self):
+        df = pd.DataFrame({"A": [1, 2], "B": [3, 4]}, index=["a", "b"]).set_flags(
+            allows_duplicate_labels=False
+        )
+        assert df.loc[["a"]].flags.allows_duplicate_labels is False
+        assert df.loc[:, ["A", "B"]].flags.allows_duplicate_labels is False
+
+    def test_to_frame(self):
+        ser = pd.Series(dtype=float).set_flags(allows_duplicate_labels=False)
+        assert ser.to_frame().flags.allows_duplicate_labels is False
+
+    @pytest.mark.parametrize("func", ["add", "sub"])
+    @pytest.mark.parametrize("frame", [False, True])
+    @pytest.mark.parametrize("other", [1, pd.Series([1, 2], name="A")])
+    def test_binops(self, func, other, frame):
+        df = pd.Series([1, 2], name="A", index=["a", "b"]).set_flags(
+            allows_duplicate_labels=False
+        )
+        if frame:
+            df = df.to_frame()
+        if isinstance(other, pd.Series) and frame:
+            other = other.to_frame()
+        func = operator.methodcaller(func, other)
+        assert df.flags.allows_duplicate_labels is False
+        assert func(df).flags.allows_duplicate_labels is False
+
+    def test_preserve_getitem(self):
+        df = pd.DataFrame({"A": [1, 2]}).set_flags(allows_duplicate_labels=False)
+        assert df[["A"]].flags.allows_duplicate_labels is False
+        assert df["A"].flags.allows_duplicate_labels is False
+        assert df.loc[0].flags.allows_duplicate_labels is False
+        assert df.loc[[0]].flags.allows_duplicate_labels is False
+        assert df.loc[0, ["A"]].flags.allows_duplicate_labels is False
+
+    def test_ndframe_getitem_caching_issue(
+        self, request, using_copy_on_write, warn_copy_on_write
+    ):
+        if not (using_copy_on_write or warn_copy_on_write):
+            request.applymarker(pytest.mark.xfail(reason="Unclear behavior."))
+        # NDFrame.__getitem__ will cache the first df['A']. May need to
+        # invalidate that cache? Update the cached entries?
+        df = pd.DataFrame({"A": [0]}).set_flags(allows_duplicate_labels=False)
+        assert df["A"].flags.allows_duplicate_labels is False
+        df.flags.allows_duplicate_labels = True
+        assert df["A"].flags.allows_duplicate_labels is True
+
+    @pytest.mark.parametrize(
+        "objs, kwargs",
+        [
+            # Series
+            (
+                [
+                    pd.Series(1, index=["a", "b"]),
+                    pd.Series(2, index=["c", "d"]),
+                ],
+                {},
+            ),
+            (
+                [
+                    pd.Series(1, index=["a", "b"]),
+                    pd.Series(2, index=["a", "b"]),
+                ],
+                {"ignore_index": True},
+            ),
+            (
+                [
+                    pd.Series(1, index=["a", "b"]),
+                    pd.Series(2, index=["a", "b"]),
+                ],
+                {"axis": 1},
+            ),
+            # Frame
+            (
+                [
+                    pd.DataFrame({"A": [1, 2]}, index=["a", "b"]),
+                    pd.DataFrame({"A": [1, 2]}, index=["c", "d"]),
+                ],
+                {},
+            ),
+            (
+                [
+                    pd.DataFrame({"A": [1, 2]}, index=["a", "b"]),
+                    pd.DataFrame({"A": [1, 2]}, index=["a", "b"]),
+                ],
+                {"ignore_index": True},
+            ),
+            (
+                [
+                    pd.DataFrame({"A": [1, 2]}, index=["a", "b"]),
+                    pd.DataFrame({"B": [1, 2]}, index=["a", "b"]),
+                ],
+                {"axis": 1},
+            ),
+            # Series / Frame
+            (
+                [
+                    pd.DataFrame({"A": [1, 2]}, index=["a", "b"]),
+                    pd.Series([1, 2], index=["a", "b"], name="B"),
+                ],
+                {"axis": 1},
+            ),
+        ],
+    )
+    def test_concat(self, objs, kwargs):
+        objs = [x.set_flags(allows_duplicate_labels=False) for x in objs]
+        result = pd.concat(objs, **kwargs)
+        assert result.flags.allows_duplicate_labels is False
+
+    @pytest.mark.parametrize(
+        "left, right, expected",
+        [
+            # false false false
+            pytest.param(
+                pd.DataFrame({"A": [0, 1]}, index=["a", "b"]).set_flags(
+                    allows_duplicate_labels=False
+                ),
+                pd.DataFrame({"B": [0, 1]}, index=["a", "d"]).set_flags(
+                    allows_duplicate_labels=False
+                ),
+                False,
+                marks=not_implemented,
+            ),
+            # false true false
+            pytest.param(
+                pd.DataFrame({"A": [0, 1]}, index=["a", "b"]).set_flags(
+                    allows_duplicate_labels=False
+                ),
+                pd.DataFrame({"B": [0, 1]}, index=["a", "d"]),
+                False,
+                marks=not_implemented,
+            ),
+            # true true true
+            (
+                pd.DataFrame({"A": [0, 1]}, index=["a", "b"]),
+                pd.DataFrame({"B": [0, 1]}, index=["a", "d"]),
+                True,
+            ),
+        ],
+    )
+    def test_merge(self, left, right, expected):
+        result = pd.merge(left, right, left_index=True, right_index=True)
+        assert result.flags.allows_duplicate_labels is expected
+
+    @not_implemented
+    def test_groupby(self):
+        # XXX: This is under tested
+        # TODO:
+        #  - apply
+        #  - transform
+        #  - Should passing a grouper that disallows duplicates propagate?
+        df = pd.DataFrame({"A": [1, 2, 3]}).set_flags(allows_duplicate_labels=False)
+        result = df.groupby([0, 0, 1]).agg("count")
+        assert result.flags.allows_duplicate_labels is False
+
+    @pytest.mark.parametrize("frame", [True, False])
+    @not_implemented
+    def test_window(self, frame):
+        df = pd.Series(
+            1,
+            index=pd.date_range("2000", periods=12),
+            name="A",
+            allows_duplicate_labels=False,
+        )
+        if frame:
+            df = df.to_frame()
+        assert df.rolling(3).mean().flags.allows_duplicate_labels is False
+        assert df.ewm(3).mean().flags.allows_duplicate_labels is False
+        assert df.expanding(3).mean().flags.allows_duplicate_labels is False
+
+
+# ----------------------------------------------------------------------------
+# Raises
+
+
+class TestRaises:
+    @pytest.mark.parametrize(
+        "cls, axes",
+        [
+            (pd.Series, {"index": ["a", "a"], "dtype": float}),
+            (pd.DataFrame, {"index": ["a", "a"]}),
+            (pd.DataFrame, {"index": ["a", "a"], "columns": ["b", "b"]}),
+            (pd.DataFrame, {"columns": ["b", "b"]}),
+        ],
+    )
+    def test_set_flags_with_duplicates(self, cls, axes):
+        result = cls(**axes)
+        assert result.flags.allows_duplicate_labels is True
+
+        msg = "Index has duplicates."
+        with pytest.raises(pd.errors.DuplicateLabelError, match=msg):
+            cls(**axes).set_flags(allows_duplicate_labels=False)
+
+    @pytest.mark.parametrize(
+        "data",
+        [
+            pd.Series(index=[0, 0], dtype=float),
+            pd.DataFrame(index=[0, 0]),
+            pd.DataFrame(columns=[0, 0]),
+        ],
+    )
+    def test_setting_allows_duplicate_labels_raises(self, data):
+        msg = "Index has duplicates."
+        with pytest.raises(pd.errors.DuplicateLabelError, match=msg):
+            data.flags.allows_duplicate_labels = False
+
+        assert data.flags.allows_duplicate_labels is True
+
+    def test_series_raises(self):
+        a = pd.Series(0, index=["a", "b"])
+        b = pd.Series([0, 1], index=["a", "b"]).set_flags(allows_duplicate_labels=False)
+        msg = "Index has duplicates."
+        with pytest.raises(pd.errors.DuplicateLabelError, match=msg):
+            pd.concat([a, b])
+
+    @pytest.mark.parametrize(
+        "getter, target",
+        [
+            (operator.itemgetter(["A", "A"]), None),
+            # loc
+            (operator.itemgetter(["a", "a"]), "loc"),
+            pytest.param(operator.itemgetter(("a", ["A", "A"])), "loc"),
+            (operator.itemgetter((["a", "a"], "A")), "loc"),
+            # iloc
+            (operator.itemgetter([0, 0]), "iloc"),
+            pytest.param(operator.itemgetter((0, [0, 0])), "iloc"),
+            pytest.param(operator.itemgetter(([0, 0], 0)), "iloc"),
+        ],
+    )
+    def test_getitem_raises(self, getter, target):
+        df = pd.DataFrame({"A": [1, 2], "B": [3, 4]}, index=["a", "b"]).set_flags(
+            allows_duplicate_labels=False
+        )
+        if target:
+            # df, df.loc, or df.iloc
+            target = getattr(df, target)
+        else:
+            target = df
+
+        msg = "Index has duplicates."
+        with pytest.raises(pd.errors.DuplicateLabelError, match=msg):
+            getter(target)
+
+    @pytest.mark.parametrize(
+        "objs, kwargs",
+        [
+            (
+                [
+                    pd.Series(1, index=[0, 1], name="a"),
+                    pd.Series(2, index=[0, 1], name="a"),
+                ],
+                {"axis": 1},
+            )
+        ],
+    )
+    def test_concat_raises(self, objs, kwargs):
+        objs = [x.set_flags(allows_duplicate_labels=False) for x in objs]
+        msg = "Index has duplicates."
+        with pytest.raises(pd.errors.DuplicateLabelError, match=msg):
+            pd.concat(objs, **kwargs)
+
+    @not_implemented
+    def test_merge_raises(self):
+        a = pd.DataFrame({"A": [0, 1, 2]}, index=["a", "b", "c"]).set_flags(
+            allows_duplicate_labels=False
+        )
+        b = pd.DataFrame({"B": [0, 1, 2]}, index=["a", "b", "b"])
+        msg = "Index has duplicates."
+        with pytest.raises(pd.errors.DuplicateLabelError, match=msg):
+            pd.merge(a, b, left_index=True, right_index=True)
+
+
+@pytest.mark.parametrize(
+    "idx",
+    [
+        pd.Index([1, 1]),
+        pd.Index(["a", "a"]),
+        pd.Index([1.1, 1.1]),
+        pd.PeriodIndex([pd.Period("2000", "D")] * 2),
+        pd.DatetimeIndex([pd.Timestamp("2000")] * 2),
+        pd.TimedeltaIndex([pd.Timedelta("1D")] * 2),
+        pd.CategoricalIndex(["a", "a"]),
+        pd.IntervalIndex([pd.Interval(0, 1)] * 2),
+        pd.MultiIndex.from_tuples([("a", 1), ("a", 1)]),
+    ],
+    ids=lambda x: type(x).__name__,
+)
+def test_raises_basic(idx):
+    msg = "Index has duplicates."
+    with pytest.raises(pd.errors.DuplicateLabelError, match=msg):
+        pd.Series(1, index=idx).set_flags(allows_duplicate_labels=False)
+
+    with pytest.raises(pd.errors.DuplicateLabelError, match=msg):
+        pd.DataFrame({"A": [1, 1]}, index=idx).set_flags(allows_duplicate_labels=False)
+
+    with pytest.raises(pd.errors.DuplicateLabelError, match=msg):
+        pd.DataFrame([[1, 2]], columns=idx).set_flags(allows_duplicate_labels=False)
+
+
+def test_format_duplicate_labels_message():
+    idx = pd.Index(["a", "b", "a", "b", "c"])
+    result = idx._format_duplicate_message()
+    expected = pd.DataFrame(
+        {"positions": [[0, 2], [1, 3]]}, index=pd.Index(["a", "b"], name="label")
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_format_duplicate_labels_message_multi():
+    idx = pd.MultiIndex.from_product([["A"], ["a", "b", "a", "b", "c"]])
+    result = idx._format_duplicate_message()
+    expected = pd.DataFrame(
+        {"positions": [[0, 2], [1, 3]]},
+        index=pd.MultiIndex.from_product([["A"], ["a", "b"]]),
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_dataframe_insert_raises():
+    df = pd.DataFrame({"A": [1, 2]}).set_flags(allows_duplicate_labels=False)
+    msg = "Cannot specify"
+    with pytest.raises(ValueError, match=msg):
+        df.insert(0, "A", [3, 4], allow_duplicates=True)
+
+
+@pytest.mark.parametrize(
+    "method, frame_only",
+    [
+        (operator.methodcaller("set_index", "A", inplace=True), True),
+        (operator.methodcaller("reset_index", inplace=True), True),
+        (operator.methodcaller("rename", lambda x: x, inplace=True), False),
+    ],
+)
+def test_inplace_raises(method, frame_only):
+    df = pd.DataFrame({"A": [0, 0], "B": [1, 2]}).set_flags(
+        allows_duplicate_labels=False
+    )
+    s = df["A"]
+    s.flags.allows_duplicate_labels = False
+    msg = "Cannot specify"
+
+    with pytest.raises(ValueError, match=msg):
+        method(df)
+    if not frame_only:
+        with pytest.raises(ValueError, match=msg):
+            method(s)
+
+
+def test_pickle():
+    a = pd.Series([1, 2]).set_flags(allows_duplicate_labels=False)
+    b = tm.round_trip_pickle(a)
+    tm.assert_series_equal(a, b)
+
+    a = pd.DataFrame({"A": []}).set_flags(allows_duplicate_labels=False)
+    b = tm.round_trip_pickle(a)
+    tm.assert_frame_equal(a, b)

venv/lib/python3.10/site-packages/pandas/tests/generic/test_finalize.py

@@ -0,0 +1,767 @@
+"""
+An exhaustive list of pandas methods exercising NDFrame.__finalize__.
+"""
+import operator
+import re
+
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+
+# TODO:
+# * Binary methods (mul, div, etc.)
+# * Binary outputs (align, etc.)
+# * top-level methods (concat, merge, get_dummies, etc.)
+# * window
+# * cumulative reductions
+
+not_implemented_mark = pytest.mark.xfail(reason="not implemented")
+
+mi = pd.MultiIndex.from_product([["a", "b"], [0, 1]], names=["A", "B"])
+
+frame_data = ({"A": [1]},)
+frame_mi_data = ({"A": [1, 2, 3, 4]}, mi)
+
+
+# Tuple of
+# - Callable: Constructor (Series, DataFrame)
+# - Tuple: Constructor args
+# - Callable: pass the constructed value with attrs set to this.
+
+_all_methods = [
+    (pd.Series, ([0],), operator.methodcaller("take", [])),
+    (pd.Series, ([0],), operator.methodcaller("__getitem__", [True])),
+    (pd.Series, ([0],), operator.methodcaller("repeat", 2)),
+    (pd.Series, ([0],), operator.methodcaller("reset_index")),
+    (pd.Series, ([0],), operator.methodcaller("reset_index", drop=True)),
+    (pd.Series, ([0],), operator.methodcaller("to_frame")),
+    (pd.Series, ([0, 0],), operator.methodcaller("drop_duplicates")),
+    (pd.Series, ([0, 0],), operator.methodcaller("duplicated")),
+    (pd.Series, ([0, 0],), operator.methodcaller("round")),
+    (pd.Series, ([0, 0],), operator.methodcaller("rename", lambda x: x + 1)),
+    (pd.Series, ([0, 0],), operator.methodcaller("rename", "name")),
+    (pd.Series, ([0, 0],), operator.methodcaller("set_axis", ["a", "b"])),
+    (pd.Series, ([0, 0],), operator.methodcaller("reindex", [1, 0])),
+    (pd.Series, ([0, 0],), operator.methodcaller("drop", [0])),
+    (pd.Series, (pd.array([0, pd.NA]),), operator.methodcaller("fillna", 0)),
+    (pd.Series, ([0, 0],), operator.methodcaller("replace", {0: 1})),
+    (pd.Series, ([0, 0],), operator.methodcaller("shift")),
+    (pd.Series, ([0, 0],), operator.methodcaller("isin", [0, 1])),
+    (pd.Series, ([0, 0],), operator.methodcaller("between", 0, 2)),
+    (pd.Series, ([0, 0],), operator.methodcaller("isna")),
+    (pd.Series, ([0, 0],), operator.methodcaller("isnull")),
+    (pd.Series, ([0, 0],), operator.methodcaller("notna")),
+    (pd.Series, ([0, 0],), operator.methodcaller("notnull")),
+    (pd.Series, ([1],), operator.methodcaller("add", pd.Series([1]))),
+    # TODO: mul, div, etc.
+    (
+        pd.Series,
+        ([0], pd.period_range("2000", periods=1)),
+        operator.methodcaller("to_timestamp"),
+    ),
+    (
+        pd.Series,
+        ([0], pd.date_range("2000", periods=1)),
+        operator.methodcaller("to_period"),
+    ),
+    pytest.param(
+        (
+            pd.DataFrame,
+            frame_data,
+            operator.methodcaller("dot", pd.DataFrame(index=["A"])),
+        ),
+        marks=pytest.mark.xfail(reason="Implement binary finalize"),
+    ),
+    (pd.DataFrame, frame_data, operator.methodcaller("transpose")),
+    (pd.DataFrame, frame_data, operator.methodcaller("__getitem__", "A")),
+    (pd.DataFrame, frame_data, operator.methodcaller("__getitem__", ["A"])),
+    (pd.DataFrame, frame_data, operator.methodcaller("__getitem__", np.array([True]))),
+    (pd.DataFrame, ({("A", "a"): [1]},), operator.methodcaller("__getitem__", ["A"])),
+    (pd.DataFrame, frame_data, operator.methodcaller("query", "A == 1")),
+    (pd.DataFrame, frame_data, operator.methodcaller("eval", "A + 1", engine="python")),
+    (pd.DataFrame, frame_data, operator.methodcaller("select_dtypes", include="int")),
+    (pd.DataFrame, frame_data, operator.methodcaller("assign", b=1)),
+    (pd.DataFrame, frame_data, operator.methodcaller("set_axis", ["A"])),
+    (pd.DataFrame, frame_data, operator.methodcaller("reindex", [0, 1])),
+    (pd.DataFrame, frame_data, operator.methodcaller("drop", columns=["A"])),
+    (pd.DataFrame, frame_data, operator.methodcaller("drop", index=[0])),
+    (pd.DataFrame, frame_data, operator.methodcaller("rename", columns={"A": "a"})),
+    (pd.DataFrame, frame_data, operator.methodcaller("rename", index=lambda x: x)),
+    (pd.DataFrame, frame_data, operator.methodcaller("fillna", "A")),
+    (pd.DataFrame, frame_data, operator.methodcaller("fillna", method="ffill")),
+    (pd.DataFrame, frame_data, operator.methodcaller("set_index", "A")),
+    (pd.DataFrame, frame_data, operator.methodcaller("reset_index")),
+    (pd.DataFrame, frame_data, operator.methodcaller("isna")),
+    (pd.DataFrame, frame_data, operator.methodcaller("isnull")),
+    (pd.DataFrame, frame_data, operator.methodcaller("notna")),
+    (pd.DataFrame, frame_data, operator.methodcaller("notnull")),
+    (pd.DataFrame, frame_data, operator.methodcaller("dropna")),
+    (pd.DataFrame, frame_data, operator.methodcaller("drop_duplicates")),
+    (pd.DataFrame, frame_data, operator.methodcaller("duplicated")),
+    (pd.DataFrame, frame_data, operator.methodcaller("sort_values", by="A")),
+    (pd.DataFrame, frame_data, operator.methodcaller("sort_index")),
+    (pd.DataFrame, frame_data, operator.methodcaller("nlargest", 1, "A")),
+    (pd.DataFrame, frame_data, operator.methodcaller("nsmallest", 1, "A")),
+    (pd.DataFrame, frame_mi_data, operator.methodcaller("swaplevel")),
+    (
+        pd.DataFrame,
+        frame_data,
+        operator.methodcaller("add", pd.DataFrame(*frame_data)),
+    ),
+    # TODO: div, mul, etc.
+    (
+        pd.DataFrame,
+        frame_data,
+        operator.methodcaller("combine", pd.DataFrame(*frame_data), operator.add),
+    ),
+    (
+        pd.DataFrame,
+        frame_data,
+        operator.methodcaller("combine_first", pd.DataFrame(*frame_data)),
+    ),
+    pytest.param(
+        (
+            pd.DataFrame,
+            frame_data,
+            operator.methodcaller("update", pd.DataFrame(*frame_data)),
+        ),
+        marks=not_implemented_mark,
+    ),
+    (pd.DataFrame, frame_data, operator.methodcaller("pivot", columns="A")),
+    (
+        pd.DataFrame,
+        ({"A": [1], "B": [1]},),
+        operator.methodcaller("pivot_table", columns="A"),
+    ),
+    (
+        pd.DataFrame,
+        ({"A": [1], "B": [1]},),
+        operator.methodcaller("pivot_table", columns="A", aggfunc=["mean", "sum"]),
+    ),
+    (pd.DataFrame, frame_data, operator.methodcaller("stack")),
+    (pd.DataFrame, frame_data, operator.methodcaller("explode", "A")),
+    (pd.DataFrame, frame_mi_data, operator.methodcaller("unstack")),
+    (
+        pd.DataFrame,
+        ({"A": ["a", "b", "c"], "B": [1, 3, 5], "C": [2, 4, 6]},),
+        operator.methodcaller("melt", id_vars=["A"], value_vars=["B"]),
+    ),
+    (pd.DataFrame, frame_data, operator.methodcaller("map", lambda x: x)),
+    pytest.param(
+        (
+            pd.DataFrame,
+            frame_data,
+            operator.methodcaller("merge", pd.DataFrame({"A": [1]})),
+        ),
+        marks=not_implemented_mark,
+    ),
+    (pd.DataFrame, frame_data, operator.methodcaller("round", 2)),
+    (pd.DataFrame, frame_data, operator.methodcaller("corr")),
+    pytest.param(
+        (pd.DataFrame, frame_data, operator.methodcaller("cov")),
+        marks=[
+            pytest.mark.filterwarnings("ignore::RuntimeWarning"),
+        ],
+    ),
+    (
+        pd.DataFrame,
+        frame_data,
+        operator.methodcaller("corrwith", pd.DataFrame(*frame_data)),
+    ),
+    (pd.DataFrame, frame_data, operator.methodcaller("count")),
+    (pd.DataFrame, frame_data, operator.methodcaller("nunique")),
+    (pd.DataFrame, frame_data, operator.methodcaller("idxmin")),
+    (pd.DataFrame, frame_data, operator.methodcaller("idxmax")),
+    (pd.DataFrame, frame_data, operator.methodcaller("mode")),
+    (pd.Series, [0], operator.methodcaller("mode")),
+    (pd.DataFrame, frame_data, operator.methodcaller("median")),
+    (
+        pd.DataFrame,
+        frame_data,
+        operator.methodcaller("quantile", numeric_only=True),
+    ),
+    (
+        pd.DataFrame,
+        frame_data,
+        operator.methodcaller("quantile", q=[0.25, 0.75], numeric_only=True),
+    ),
+    (
+        pd.DataFrame,
+        ({"A": [pd.Timedelta(days=1), pd.Timedelta(days=2)]},),
+        operator.methodcaller("quantile", numeric_only=False),
+    ),
+    (
+        pd.DataFrame,
+        ({"A": [np.datetime64("2022-01-01"), np.datetime64("2022-01-02")]},),
+        operator.methodcaller("quantile", numeric_only=True),
+    ),
+    (
+        pd.DataFrame,
+        ({"A": [1]}, [pd.Period("2000", "D")]),
+        operator.methodcaller("to_timestamp"),
+    ),
+    (
+        pd.DataFrame,
+        ({"A": [1]}, [pd.Timestamp("2000")]),
+        operator.methodcaller("to_period", freq="D"),
+    ),
+    (pd.DataFrame, frame_mi_data, operator.methodcaller("isin", [1])),
+    (pd.DataFrame, frame_mi_data, operator.methodcaller("isin", pd.Series([1]))),
+    (
+        pd.DataFrame,
+        frame_mi_data,
+        operator.methodcaller("isin", pd.DataFrame({"A": [1]})),
+    ),
+    (pd.DataFrame, frame_mi_data, operator.methodcaller("droplevel", "A")),
+    (pd.DataFrame, frame_data, operator.methodcaller("pop", "A")),
+    # Squeeze on columns, otherwise we'll end up with a scalar
+    (pd.DataFrame, frame_data, operator.methodcaller("squeeze", axis="columns")),
+    (pd.Series, ([1, 2],), operator.methodcaller("squeeze")),
+    (pd.Series, ([1, 2],), operator.methodcaller("rename_axis", index="a")),
+    (pd.DataFrame, frame_data, operator.methodcaller("rename_axis", columns="a")),
+    # Unary ops
+    (pd.DataFrame, frame_data, operator.neg),
+    (pd.Series, [1], operator.neg),
+    (pd.DataFrame, frame_data, operator.pos),
+    (pd.Series, [1], operator.pos),
+    (pd.DataFrame, frame_data, operator.inv),
+    (pd.Series, [1], operator.inv),
+    (pd.DataFrame, frame_data, abs),
+    (pd.Series, [1], abs),
+    (pd.DataFrame, frame_data, round),
+    (pd.Series, [1], round),
+    (pd.DataFrame, frame_data, operator.methodcaller("take", [0, 0])),
+    (pd.DataFrame, frame_mi_data, operator.methodcaller("xs", "a")),
+    (pd.Series, (1, mi), operator.methodcaller("xs", "a")),
+    (pd.DataFrame, frame_data, operator.methodcaller("get", "A")),
+    (
+        pd.DataFrame,
+        frame_data,
+        operator.methodcaller("reindex_like", pd.DataFrame({"A": [1, 2, 3]})),
+    ),
+    (
+        pd.Series,
+        frame_data,
+        operator.methodcaller("reindex_like", pd.Series([0, 1, 2])),
+    ),
+    (pd.DataFrame, frame_data, operator.methodcaller("add_prefix", "_")),
+    (pd.DataFrame, frame_data, operator.methodcaller("add_suffix", "_")),
+    (pd.Series, (1, ["a", "b"]), operator.methodcaller("add_prefix", "_")),
+    (pd.Series, (1, ["a", "b"]), operator.methodcaller("add_suffix", "_")),
+    (pd.Series, ([3, 2],), operator.methodcaller("sort_values")),
+    (pd.Series, ([1] * 10,), operator.methodcaller("head")),
+    (pd.DataFrame, ({"A": [1] * 10},), operator.methodcaller("head")),
+    (pd.Series, ([1] * 10,), operator.methodcaller("tail")),
+    (pd.DataFrame, ({"A": [1] * 10},), operator.methodcaller("tail")),
+    (pd.Series, ([1, 2],), operator.methodcaller("sample", n=2, replace=True)),
+    (pd.DataFrame, (frame_data,), operator.methodcaller("sample", n=2, replace=True)),
+    (pd.Series, ([1, 2],), operator.methodcaller("astype", float)),
+    (pd.DataFrame, frame_data, operator.methodcaller("astype", float)),
+    (pd.Series, ([1, 2],), operator.methodcaller("copy")),
+    (pd.DataFrame, frame_data, operator.methodcaller("copy")),
+    (pd.Series, ([1, 2], None, object), operator.methodcaller("infer_objects")),
+    (
+        pd.DataFrame,
+        ({"A": np.array([1, 2], dtype=object)},),
+        operator.methodcaller("infer_objects"),
+    ),
+    (pd.Series, ([1, 2],), operator.methodcaller("convert_dtypes")),
+    (pd.DataFrame, frame_data, operator.methodcaller("convert_dtypes")),
+    (pd.Series, ([1, None, 3],), operator.methodcaller("interpolate")),
+    (pd.DataFrame, ({"A": [1, None, 3]},), operator.methodcaller("interpolate")),
+    (pd.Series, ([1, 2],), operator.methodcaller("clip", lower=1)),
+    (pd.DataFrame, frame_data, operator.methodcaller("clip", lower=1)),
+    (
+        pd.Series,
+        (1, pd.date_range("2000", periods=4)),
+        operator.methodcaller("asfreq", "h"),
+    ),
+    (
+        pd.DataFrame,
+        ({"A": [1, 1, 1, 1]}, pd.date_range("2000", periods=4)),
+        operator.methodcaller("asfreq", "h"),
+    ),
+    (
+        pd.Series,
+        (1, pd.date_range("2000", periods=4)),
+        operator.methodcaller("at_time", "12:00"),
+    ),
+    (
+        pd.DataFrame,
+        ({"A": [1, 1, 1, 1]}, pd.date_range("2000", periods=4)),
+        operator.methodcaller("at_time", "12:00"),
+    ),
+    (
+        pd.Series,
+        (1, pd.date_range("2000", periods=4)),
+        operator.methodcaller("between_time", "12:00", "13:00"),
+    ),
+    (
+        pd.DataFrame,
+        ({"A": [1, 1, 1, 1]}, pd.date_range("2000", periods=4)),
+        operator.methodcaller("between_time", "12:00", "13:00"),
+    ),
+    (
+        pd.Series,
+        (1, pd.date_range("2000", periods=4)),
+        operator.methodcaller("last", "3D"),
+    ),
+    (
+        pd.DataFrame,
+        ({"A": [1, 1, 1, 1]}, pd.date_range("2000", periods=4)),
+        operator.methodcaller("last", "3D"),
+    ),
+    (pd.Series, ([1, 2],), operator.methodcaller("rank")),
+    (pd.DataFrame, frame_data, operator.methodcaller("rank")),
+    (pd.Series, ([1, 2],), operator.methodcaller("where", np.array([True, False]))),
+    (pd.DataFrame, frame_data, operator.methodcaller("where", np.array([[True]]))),
+    (pd.Series, ([1, 2],), operator.methodcaller("mask", np.array([True, False]))),
+    (pd.DataFrame, frame_data, operator.methodcaller("mask", np.array([[True]]))),
+    (pd.Series, ([1, 2],), operator.methodcaller("truncate", before=0)),
+    (pd.DataFrame, frame_data, operator.methodcaller("truncate", before=0)),
+    (
+        pd.Series,
+        (1, pd.date_range("2000", periods=4, tz="UTC")),
+        operator.methodcaller("tz_convert", "CET"),
+    ),
+    (
+        pd.DataFrame,
+        ({"A": [1, 1, 1, 1]}, pd.date_range("2000", periods=4, tz="UTC")),
+        operator.methodcaller("tz_convert", "CET"),
+    ),
+    (
+        pd.Series,
+        (1, pd.date_range("2000", periods=4)),
+        operator.methodcaller("tz_localize", "CET"),
+    ),
+    (
+        pd.DataFrame,
+        ({"A": [1, 1, 1, 1]}, pd.date_range("2000", periods=4)),
+        operator.methodcaller("tz_localize", "CET"),
+    ),
+    (pd.Series, ([1, 2],), operator.methodcaller("describe")),
+    (pd.DataFrame, frame_data, operator.methodcaller("describe")),
+    (pd.Series, ([1, 2],), operator.methodcaller("pct_change")),
+    (pd.DataFrame, frame_data, operator.methodcaller("pct_change")),
+    (pd.Series, ([1],), operator.methodcaller("transform", lambda x: x - x.min())),
+    (
+        pd.DataFrame,
+        frame_mi_data,
+        operator.methodcaller("transform", lambda x: x - x.min()),
+    ),
+    (pd.Series, ([1],), operator.methodcaller("apply", lambda x: x)),
+    (pd.DataFrame, frame_mi_data, operator.methodcaller("apply", lambda x: x)),
+    # Cumulative reductions
+    (pd.Series, ([1],), operator.methodcaller("cumsum")),
+    (pd.DataFrame, frame_data, operator.methodcaller("cumsum")),
+    (pd.Series, ([1],), operator.methodcaller("cummin")),
+    (pd.DataFrame, frame_data, operator.methodcaller("cummin")),
+    (pd.Series, ([1],), operator.methodcaller("cummax")),
+    (pd.DataFrame, frame_data, operator.methodcaller("cummax")),
+    (pd.Series, ([1],), operator.methodcaller("cumprod")),
+    (pd.DataFrame, frame_data, operator.methodcaller("cumprod")),
+    # Reductions
+    (pd.DataFrame, frame_data, operator.methodcaller("any")),
+    (pd.DataFrame, frame_data, operator.methodcaller("all")),
+    (pd.DataFrame, frame_data, operator.methodcaller("min")),
+    (pd.DataFrame, frame_data, operator.methodcaller("max")),
+    (pd.DataFrame, frame_data, operator.methodcaller("sum")),
+    (pd.DataFrame, frame_data, operator.methodcaller("std")),
+    (pd.DataFrame, frame_data, operator.methodcaller("mean")),
+    (pd.DataFrame, frame_data, operator.methodcaller("prod")),
+    (pd.DataFrame, frame_data, operator.methodcaller("sem")),
+    (pd.DataFrame, frame_data, operator.methodcaller("skew")),
+    (pd.DataFrame, frame_data, operator.methodcaller("kurt")),
+]
+
+
+def idfn(x):
+    xpr = re.compile(r"'(.*)?'")
+    m = xpr.search(str(x))
+    if m:
+        return m.group(1)
+    else:
+        return str(x)
+
+
+@pytest.fixture(params=_all_methods, ids=lambda x: idfn(x[-1]))
+def ndframe_method(request):
+    """
+    An NDFrame method returning an NDFrame.
+    """
+    return request.param
+
+
+@pytest.mark.filterwarnings(
+    "ignore:DataFrame.fillna with 'method' is deprecated:FutureWarning",
+    "ignore:last is deprecated:FutureWarning",
+)
+def test_finalize_called(ndframe_method):
+    cls, init_args, method = ndframe_method
+    ndframe = cls(*init_args)
+
+    ndframe.attrs = {"a": 1}
+    result = method(ndframe)
+
+    assert result.attrs == {"a": 1}
+
+
+@pytest.mark.parametrize(
+    "data",
+    [
+        pd.Series(1, pd.date_range("2000", periods=4)),
+        pd.DataFrame({"A": [1, 1, 1, 1]}, pd.date_range("2000", periods=4)),
+    ],
+)
+def test_finalize_first(data):
+    deprecated_msg = "first is deprecated"
+
+    data.attrs = {"a": 1}
+    with tm.assert_produces_warning(FutureWarning, match=deprecated_msg):
+        result = data.first("3D")
+        assert result.attrs == {"a": 1}
+
+
+@pytest.mark.parametrize(
+    "data",
+    [
+        pd.Series(1, pd.date_range("2000", periods=4)),
+        pd.DataFrame({"A": [1, 1, 1, 1]}, pd.date_range("2000", periods=4)),
+    ],
+)
+def test_finalize_last(data):
+    # GH 53710
+    deprecated_msg = "last is deprecated"
+
+    data.attrs = {"a": 1}
+    with tm.assert_produces_warning(FutureWarning, match=deprecated_msg):
+        result = data.last("3D")
+        assert result.attrs == {"a": 1}
+
+
+@not_implemented_mark
+def test_finalize_called_eval_numexpr():
+    pytest.importorskip("numexpr")
+    df = pd.DataFrame({"A": [1, 2]})
+    df.attrs["A"] = 1
+    result = df.eval("A + 1", engine="numexpr")
+    assert result.attrs == {"A": 1}
+
+
+# ----------------------------------------------------------------------------
+# Binary operations
+
+
+@pytest.mark.parametrize("annotate", ["left", "right", "both"])
+@pytest.mark.parametrize(
+    "args",
+    [
+        (1, pd.Series([1])),
+        (1, pd.DataFrame({"A": [1]})),
+        (pd.Series([1]), 1),
+        (pd.DataFrame({"A": [1]}), 1),
+        (pd.Series([1]), pd.Series([1])),
+        (pd.DataFrame({"A": [1]}), pd.DataFrame({"A": [1]})),
+        (pd.Series([1]), pd.DataFrame({"A": [1]})),
+        (pd.DataFrame({"A": [1]}), pd.Series([1])),
+    ],
+    ids=lambda x: f"({type(x[0]).__name__},{type(x[1]).__name__})",
+)
+def test_binops(request, args, annotate, all_binary_operators):
+    # This generates 624 tests... Is that needed?
+    left, right = args
+    if isinstance(left, (pd.DataFrame, pd.Series)):
+        left.attrs = {}
+    if isinstance(right, (pd.DataFrame, pd.Series)):
+        right.attrs = {}
+
+    if annotate == "left" and isinstance(left, int):
+        pytest.skip("left is an int and doesn't support .attrs")
+    if annotate == "right" and isinstance(right, int):
+        pytest.skip("right is an int and doesn't support .attrs")
+
+    if not (isinstance(left, int) or isinstance(right, int)) and annotate != "both":
+        if not all_binary_operators.__name__.startswith("r"):
+            if annotate == "right" and isinstance(left, type(right)):
+                request.applymarker(
+                    pytest.mark.xfail(
+                        reason=f"{all_binary_operators} doesn't work when right has "
+                        f"attrs and both are {type(left)}"
+                    )
+                )
+            if not isinstance(left, type(right)):
+                if annotate == "left" and isinstance(left, pd.Series):
+                    request.applymarker(
+                        pytest.mark.xfail(
+                            reason=f"{all_binary_operators} doesn't work when the "
+                            "objects are different Series has attrs"
+                        )
+                    )
+                elif annotate == "right" and isinstance(right, pd.Series):
+                    request.applymarker(
+                        pytest.mark.xfail(
+                            reason=f"{all_binary_operators} doesn't work when the "
+                            "objects are different Series has attrs"
+                        )
+                    )
+        else:
+            if annotate == "left" and isinstance(left, type(right)):
+                request.applymarker(
+                    pytest.mark.xfail(
+                        reason=f"{all_binary_operators} doesn't work when left has "
+                        f"attrs and both are {type(left)}"
+                    )
+                )
+            if not isinstance(left, type(right)):
+                if annotate == "right" and isinstance(right, pd.Series):
+                    request.applymarker(
+                        pytest.mark.xfail(
+                            reason=f"{all_binary_operators} doesn't work when the "
+                            "objects are different Series has attrs"
+                        )
+                    )
+                elif annotate == "left" and isinstance(left, pd.Series):
+                    request.applymarker(
+                        pytest.mark.xfail(
+                            reason=f"{all_binary_operators} doesn't work when the "
+                            "objects are different Series has attrs"
+                        )
+                    )
+    if annotate in {"left", "both"} and not isinstance(left, int):
+        left.attrs = {"a": 1}
+    if annotate in {"right", "both"} and not isinstance(right, int):
+        right.attrs = {"a": 1}
+
+    is_cmp = all_binary_operators in [
+        operator.eq,
+        operator.ne,
+        operator.gt,
+        operator.ge,
+        operator.lt,
+        operator.le,
+    ]
+    if is_cmp and isinstance(left, pd.DataFrame) and isinstance(right, pd.Series):
+        # in 2.0 silent alignment on comparisons was removed xref GH#28759
+        left, right = left.align(right, axis=1, copy=False)
+    elif is_cmp and isinstance(left, pd.Series) and isinstance(right, pd.DataFrame):
+        right, left = right.align(left, axis=1, copy=False)
+
+    result = all_binary_operators(left, right)
+    assert result.attrs == {"a": 1}
+
+
+# ----------------------------------------------------------------------------
+# Accessors
+
+
+@pytest.mark.parametrize(
+    "method",
+    [
+        operator.methodcaller("capitalize"),
+        operator.methodcaller("casefold"),
+        operator.methodcaller("cat", ["a"]),
+        operator.methodcaller("contains", "a"),
+        operator.methodcaller("count", "a"),
+        operator.methodcaller("encode", "utf-8"),
+        operator.methodcaller("endswith", "a"),
+        operator.methodcaller("extract", r"(\w)(\d)"),
+        operator.methodcaller("extract", r"(\w)(\d)", expand=False),
+        operator.methodcaller("find", "a"),
+        operator.methodcaller("findall", "a"),
+        operator.methodcaller("get", 0),
+        operator.methodcaller("index", "a"),
+        operator.methodcaller("len"),
+        operator.methodcaller("ljust", 4),
+        operator.methodcaller("lower"),
+        operator.methodcaller("lstrip"),
+        operator.methodcaller("match", r"\w"),
+        operator.methodcaller("normalize", "NFC"),
+        operator.methodcaller("pad", 4),
+        operator.methodcaller("partition", "a"),
+        operator.methodcaller("repeat", 2),
+        operator.methodcaller("replace", "a", "b"),
+        operator.methodcaller("rfind", "a"),
+        operator.methodcaller("rindex", "a"),
+        operator.methodcaller("rjust", 4),
+        operator.methodcaller("rpartition", "a"),
+        operator.methodcaller("rstrip"),
+        operator.methodcaller("slice", 4),
+        operator.methodcaller("slice_replace", 1, repl="a"),
+        operator.methodcaller("startswith", "a"),
+        operator.methodcaller("strip"),
+        operator.methodcaller("swapcase"),
+        operator.methodcaller("translate", {"a": "b"}),
+        operator.methodcaller("upper"),
+        operator.methodcaller("wrap", 4),
+        operator.methodcaller("zfill", 4),
+        operator.methodcaller("isalnum"),
+        operator.methodcaller("isalpha"),
+        operator.methodcaller("isdigit"),
+        operator.methodcaller("isspace"),
+        operator.methodcaller("islower"),
+        operator.methodcaller("isupper"),
+        operator.methodcaller("istitle"),
+        operator.methodcaller("isnumeric"),
+        operator.methodcaller("isdecimal"),
+        operator.methodcaller("get_dummies"),
+    ],
+    ids=idfn,
+)
+def test_string_method(method):
+    s = pd.Series(["a1"])
+    s.attrs = {"a": 1}
+    result = method(s.str)
+    assert result.attrs == {"a": 1}
+
+
+@pytest.mark.parametrize(
+    "method",
+    [
+        operator.methodcaller("to_period"),
+        operator.methodcaller("tz_localize", "CET"),
+        operator.methodcaller("normalize"),
+        operator.methodcaller("strftime", "%Y"),
+        operator.methodcaller("round", "h"),
+        operator.methodcaller("floor", "h"),
+        operator.methodcaller("ceil", "h"),
+        operator.methodcaller("month_name"),
+        operator.methodcaller("day_name"),
+    ],
+    ids=idfn,
+)
+def test_datetime_method(method):
+    s = pd.Series(pd.date_range("2000", periods=4))
+    s.attrs = {"a": 1}
+    result = method(s.dt)
+    assert result.attrs == {"a": 1}
+
+
+@pytest.mark.parametrize(
+    "attr",
+    [
+        "date",
+        "time",
+        "timetz",
+        "year",
+        "month",
+        "day",
+        "hour",
+        "minute",
+        "second",
+        "microsecond",
+        "nanosecond",
+        "dayofweek",
+        "day_of_week",
+        "dayofyear",
+        "day_of_year",
+        "quarter",
+        "is_month_start",
+        "is_month_end",
+        "is_quarter_start",
+        "is_quarter_end",
+        "is_year_start",
+        "is_year_end",
+        "is_leap_year",
+        "daysinmonth",
+        "days_in_month",
+    ],
+)
+def test_datetime_property(attr):
+    s = pd.Series(pd.date_range("2000", periods=4))
+    s.attrs = {"a": 1}
+    result = getattr(s.dt, attr)
+    assert result.attrs == {"a": 1}
+
+
+@pytest.mark.parametrize(
+    "attr", ["days", "seconds", "microseconds", "nanoseconds", "components"]
+)
+def test_timedelta_property(attr):
+    s = pd.Series(pd.timedelta_range("2000", periods=4))
+    s.attrs = {"a": 1}
+    result = getattr(s.dt, attr)
+    assert result.attrs == {"a": 1}
+
+
+@pytest.mark.parametrize("method", [operator.methodcaller("total_seconds")])
+def test_timedelta_methods(method):
+    s = pd.Series(pd.timedelta_range("2000", periods=4))
+    s.attrs = {"a": 1}
+    result = method(s.dt)
+    assert result.attrs == {"a": 1}
+
+
+@pytest.mark.parametrize(
+    "method",
+    [
+        operator.methodcaller("add_categories", ["c"]),
+        operator.methodcaller("as_ordered"),
+        operator.methodcaller("as_unordered"),
+        lambda x: getattr(x, "codes"),
+        operator.methodcaller("remove_categories", "a"),
+        operator.methodcaller("remove_unused_categories"),
+        operator.methodcaller("rename_categories", {"a": "A", "b": "B"}),
+        operator.methodcaller("reorder_categories", ["b", "a"]),
+        operator.methodcaller("set_categories", ["A", "B"]),
+    ],
+)
+@not_implemented_mark
+def test_categorical_accessor(method):
+    s = pd.Series(["a", "b"], dtype="category")
+    s.attrs = {"a": 1}
+    result = method(s.cat)
+    assert result.attrs == {"a": 1}
+
+
+# ----------------------------------------------------------------------------
+# Groupby
+
+
+@pytest.mark.parametrize(
+    "obj", [pd.Series([0, 0]), pd.DataFrame({"A": [0, 1], "B": [1, 2]})]
+)
+@pytest.mark.parametrize(
+    "method",
+    [
+        operator.methodcaller("sum"),
+        lambda x: x.apply(lambda y: y),
+        lambda x: x.agg("sum"),
+        lambda x: x.agg("mean"),
+        lambda x: x.agg("median"),
+    ],
+)
+def test_groupby_finalize(obj, method):
+    obj.attrs = {"a": 1}
+    result = method(obj.groupby([0, 0], group_keys=False))
+    assert result.attrs == {"a": 1}
+
+
+@pytest.mark.parametrize(
+    "obj", [pd.Series([0, 0]), pd.DataFrame({"A": [0, 1], "B": [1, 2]})]
+)
+@pytest.mark.parametrize(
+    "method",
+    [
+        lambda x: x.agg(["sum", "count"]),
+        lambda x: x.agg("std"),
+        lambda x: x.agg("var"),
+        lambda x: x.agg("sem"),
+        lambda x: x.agg("size"),
+        lambda x: x.agg("ohlc"),
+    ],
+)
+@not_implemented_mark
+def test_groupby_finalize_not_implemented(obj, method):
+    obj.attrs = {"a": 1}
+    result = method(obj.groupby([0, 0]))
+    assert result.attrs == {"a": 1}
+
+
+def test_finalize_frame_series_name():
+    # https://github.com/pandas-dev/pandas/pull/37186/files#r506978889
+    # ensure we don't copy the column `name` to the Series.
+    df = pd.DataFrame({"name": [1, 2]})
+    result = pd.Series([1, 2]).__finalize__(df)
+    assert result.name is None

venv/lib/python3.10/site-packages/pandas/tests/generic/test_frame.py

@@ -0,0 +1,209 @@
+from copy import deepcopy
+from operator import methodcaller
+
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    MultiIndex,
+    Series,
+    date_range,
+)
+import pandas._testing as tm
+
+
+class TestDataFrame:
+    @pytest.mark.parametrize("func", ["_set_axis_name", "rename_axis"])
+    def test_set_axis_name(self, func):
+        df = DataFrame([[1, 2], [3, 4]])
+
+        result = methodcaller(func, "foo")(df)
+        assert df.index.name is None
+        assert result.index.name == "foo"
+
+        result = methodcaller(func, "cols", axis=1)(df)
+        assert df.columns.name is None
+        assert result.columns.name == "cols"
+
+    @pytest.mark.parametrize("func", ["_set_axis_name", "rename_axis"])
+    def test_set_axis_name_mi(self, func):
+        df = DataFrame(
+            np.empty((3, 3)),
+            index=MultiIndex.from_tuples([("A", x) for x in list("aBc")]),
+            columns=MultiIndex.from_tuples([("C", x) for x in list("xyz")]),
+        )
+
+        level_names = ["L1", "L2"]
+
+        result = methodcaller(func, level_names)(df)
+        assert result.index.names == level_names
+        assert result.columns.names == [None, None]
+
+        result = methodcaller(func, level_names, axis=1)(df)
+        assert result.columns.names == ["L1", "L2"]
+        assert result.index.names == [None, None]
+
+    def test_nonzero_single_element(self):
+        # allow single item via bool method
+        msg_warn = (
+            "DataFrame.bool is now deprecated and will be removed "
+            "in future version of pandas"
+        )
+        df = DataFrame([[True]])
+        df1 = DataFrame([[False]])
+        with tm.assert_produces_warning(FutureWarning, match=msg_warn):
+            assert df.bool()
+
+        with tm.assert_produces_warning(FutureWarning, match=msg_warn):
+            assert not df1.bool()
+
+        df = DataFrame([[False, False]])
+        msg_err = "The truth value of a DataFrame is ambiguous"
+        with pytest.raises(ValueError, match=msg_err):
+            bool(df)
+
+        with tm.assert_produces_warning(FutureWarning, match=msg_warn):
+            with pytest.raises(ValueError, match=msg_err):
+                df.bool()
+
+    def test_metadata_propagation_indiv_groupby(self):
+        # groupby
+        df = DataFrame(
+            {
+                "A": ["foo", "bar", "foo", "bar", "foo", "bar", "foo", "foo"],
+                "B": ["one", "one", "two", "three", "two", "two", "one", "three"],
+                "C": np.random.default_rng(2).standard_normal(8),
+                "D": np.random.default_rng(2).standard_normal(8),
+            }
+        )
+        result = df.groupby("A").sum()
+        tm.assert_metadata_equivalent(df, result)
+
+    def test_metadata_propagation_indiv_resample(self):
+        # resample
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((1000, 2)),
+            index=date_range("20130101", periods=1000, freq="s"),
+        )
+        result = df.resample("1min")
+        tm.assert_metadata_equivalent(df, result)
+
+    def test_metadata_propagation_indiv(self, monkeypatch):
+        # merging with override
+        # GH 6923
+
+        def finalize(self, other, method=None, **kwargs):
+            for name in self._metadata:
+                if method == "merge":
+                    left, right = other.left, other.right
+                    value = getattr(left, name, "") + "|" + getattr(right, name, "")
+                    object.__setattr__(self, name, value)
+                elif method == "concat":
+                    value = "+".join(
+                        [getattr(o, name) for o in other.objs if getattr(o, name, None)]
+                    )
+                    object.__setattr__(self, name, value)
+                else:
+                    object.__setattr__(self, name, getattr(other, name, ""))
+
+            return self
+
+        with monkeypatch.context() as m:
+            m.setattr(DataFrame, "_metadata", ["filename"])
+            m.setattr(DataFrame, "__finalize__", finalize)
+
+            df1 = DataFrame(
+                np.random.default_rng(2).integers(0, 4, (3, 2)), columns=["a", "b"]
+            )
+            df2 = DataFrame(
+                np.random.default_rng(2).integers(0, 4, (3, 2)), columns=["c", "d"]
+            )
+            DataFrame._metadata = ["filename"]
+            df1.filename = "fname1.csv"
+            df2.filename = "fname2.csv"
+
+            result = df1.merge(df2, left_on=["a"], right_on=["c"], how="inner")
+            assert result.filename == "fname1.csv|fname2.csv"
+
+            # concat
+            # GH#6927
+            df1 = DataFrame(
+                np.random.default_rng(2).integers(0, 4, (3, 2)), columns=list("ab")
+            )
+            df1.filename = "foo"
+
+            result = pd.concat([df1, df1])
+            assert result.filename == "foo+foo"
+
+    def test_set_attribute(self):
+        # Test for consistent setattr behavior when an attribute and a column
+        # have the same name (Issue #8994)
+        df = DataFrame({"x": [1, 2, 3]})
+
+        df.y = 2
+        df["y"] = [2, 4, 6]
+        df.y = 5
+
+        assert df.y == 5
+        tm.assert_series_equal(df["y"], Series([2, 4, 6], name="y"))
+
+    def test_deepcopy_empty(self):
+        # This test covers empty frame copying with non-empty column sets
+        # as reported in issue GH15370
+        empty_frame = DataFrame(data=[], index=[], columns=["A"])
+        empty_frame_copy = deepcopy(empty_frame)
+
+        tm.assert_frame_equal(empty_frame_copy, empty_frame)
+
+
+# formerly in Generic but only test DataFrame
+class TestDataFrame2:
+    @pytest.mark.parametrize("value", [1, "True", [1, 2, 3], 5.0])
+    def test_validate_bool_args(self, value):
+        df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+
+        msg = 'For argument "inplace" expected type bool, received type'
+        with pytest.raises(ValueError, match=msg):
+            df.copy().rename_axis(mapper={"a": "x", "b": "y"}, axis=1, inplace=value)
+
+        with pytest.raises(ValueError, match=msg):
+            df.copy().drop("a", axis=1, inplace=value)
+
+        with pytest.raises(ValueError, match=msg):
+            df.copy().fillna(value=0, inplace=value)
+
+        with pytest.raises(ValueError, match=msg):
+            df.copy().replace(to_replace=1, value=7, inplace=value)
+
+        with pytest.raises(ValueError, match=msg):
+            df.copy().interpolate(inplace=value)
+
+        with pytest.raises(ValueError, match=msg):
+            df.copy()._where(cond=df.a > 2, inplace=value)
+
+        with pytest.raises(ValueError, match=msg):
+            df.copy().mask(cond=df.a > 2, inplace=value)
+
+    def test_unexpected_keyword(self):
+        # GH8597
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((5, 2)), columns=["jim", "joe"]
+        )
+        ca = pd.Categorical([0, 0, 2, 2, 3, np.nan])
+        ts = df["joe"].copy()
+        ts[2] = np.nan
+
+        msg = "unexpected keyword"
+        with pytest.raises(TypeError, match=msg):
+            df.drop("joe", axis=1, in_place=True)
+
+        with pytest.raises(TypeError, match=msg):
+            df.reindex([1, 0], inplace=True)
+
+        with pytest.raises(TypeError, match=msg):
+            ca.fillna(0, inplace=True)
+
+        with pytest.raises(TypeError, match=msg):
+            ts.fillna(0, in_place=True)

venv/lib/python3.10/site-packages/pandas/tests/generic/test_generic.py

@@ -0,0 +1,504 @@
+from copy import (
+    copy,
+    deepcopy,
+)
+
+import numpy as np
+import pytest
+
+from pandas.core.dtypes.common import is_scalar
+
+from pandas import (
+    DataFrame,
+    Index,
+    Series,
+    date_range,
+)
+import pandas._testing as tm
+
+# ----------------------------------------------------------------------
+# Generic types test cases
+
+
+def construct(box, shape, value=None, dtype=None, **kwargs):
+    """
+    construct an object for the given shape
+    if value is specified use that if its a scalar
+    if value is an array, repeat it as needed
+    """
+    if isinstance(shape, int):
+        shape = tuple([shape] * box._AXIS_LEN)
+    if value is not None:
+        if is_scalar(value):
+            if value == "empty":
+                arr = None
+                dtype = np.float64
+
+                # remove the info axis
+                kwargs.pop(box._info_axis_name, None)
+            else:
+                arr = np.empty(shape, dtype=dtype)
+                arr.fill(value)
+        else:
+            fshape = np.prod(shape)
+            arr = value.ravel()
+            new_shape = fshape / arr.shape[0]
+            if fshape % arr.shape[0] != 0:
+                raise Exception("invalid value passed in construct")
+
+            arr = np.repeat(arr, new_shape).reshape(shape)
+    else:
+        arr = np.random.default_rng(2).standard_normal(shape)
+    return box(arr, dtype=dtype, **kwargs)
+
+
+class TestGeneric:
+    @pytest.mark.parametrize(
+        "func",
+        [
+            str.lower,
+            {x: x.lower() for x in list("ABCD")},
+            Series({x: x.lower() for x in list("ABCD")}),
+        ],
+    )
+    def test_rename(self, frame_or_series, func):
+        # single axis
+        idx = list("ABCD")
+
+        for axis in frame_or_series._AXIS_ORDERS:
+            kwargs = {axis: idx}
+            obj = construct(frame_or_series, 4, **kwargs)
+
+            # rename a single axis
+            result = obj.rename(**{axis: func})
+            expected = obj.copy()
+            setattr(expected, axis, list("abcd"))
+            tm.assert_equal(result, expected)
+
+    def test_get_numeric_data(self, frame_or_series):
+        n = 4
+        kwargs = {
+            frame_or_series._get_axis_name(i): list(range(n))
+            for i in range(frame_or_series._AXIS_LEN)
+        }
+
+        # get the numeric data
+        o = construct(frame_or_series, n, **kwargs)
+        result = o._get_numeric_data()
+        tm.assert_equal(result, o)
+
+        # non-inclusion
+        result = o._get_bool_data()
+        expected = construct(frame_or_series, n, value="empty", **kwargs)
+        if isinstance(o, DataFrame):
+            # preserve columns dtype
+            expected.columns = o.columns[:0]
+        # https://github.com/pandas-dev/pandas/issues/50862
+        tm.assert_equal(result.reset_index(drop=True), expected)
+
+        # get the bool data
+        arr = np.array([True, True, False, True])
+        o = construct(frame_or_series, n, value=arr, **kwargs)
+        result = o._get_numeric_data()
+        tm.assert_equal(result, o)
+
+    def test_nonzero(self, frame_or_series):
+        # GH 4633
+        # look at the boolean/nonzero behavior for objects
+        obj = construct(frame_or_series, shape=4)
+        msg = f"The truth value of a {frame_or_series.__name__} is ambiguous"
+        with pytest.raises(ValueError, match=msg):
+            bool(obj == 0)
+        with pytest.raises(ValueError, match=msg):
+            bool(obj == 1)
+        with pytest.raises(ValueError, match=msg):
+            bool(obj)
+
+        obj = construct(frame_or_series, shape=4, value=1)
+        with pytest.raises(ValueError, match=msg):
+            bool(obj == 0)
+        with pytest.raises(ValueError, match=msg):
+            bool(obj == 1)
+        with pytest.raises(ValueError, match=msg):
+            bool(obj)
+
+        obj = construct(frame_or_series, shape=4, value=np.nan)
+        with pytest.raises(ValueError, match=msg):
+            bool(obj == 0)
+        with pytest.raises(ValueError, match=msg):
+            bool(obj == 1)
+        with pytest.raises(ValueError, match=msg):
+            bool(obj)
+
+        # empty
+        obj = construct(frame_or_series, shape=0)
+        with pytest.raises(ValueError, match=msg):
+            bool(obj)
+
+        # invalid behaviors
+
+        obj1 = construct(frame_or_series, shape=4, value=1)
+        obj2 = construct(frame_or_series, shape=4, value=1)
+
+        with pytest.raises(ValueError, match=msg):
+            if obj1:
+                pass
+
+        with pytest.raises(ValueError, match=msg):
+            obj1 and obj2
+        with pytest.raises(ValueError, match=msg):
+            obj1 or obj2
+        with pytest.raises(ValueError, match=msg):
+            not obj1
+
+    def test_frame_or_series_compound_dtypes(self, frame_or_series):
+        # see gh-5191
+        # Compound dtypes should raise NotImplementedError.
+
+        def f(dtype):
+            return construct(frame_or_series, shape=3, value=1, dtype=dtype)
+
+        msg = (
+            "compound dtypes are not implemented "
+            f"in the {frame_or_series.__name__} constructor"
+        )
+
+        with pytest.raises(NotImplementedError, match=msg):
+            f([("A", "datetime64[h]"), ("B", "str"), ("C", "int32")])
+
+        # these work (though results may be unexpected)
+        f("int64")
+        f("float64")
+        f("M8[ns]")
+
+    def test_metadata_propagation(self, frame_or_series):
+        # check that the metadata matches up on the resulting ops
+
+        o = construct(frame_or_series, shape=3)
+        o.name = "foo"
+        o2 = construct(frame_or_series, shape=3)
+        o2.name = "bar"
+
+        # ----------
+        # preserving
+        # ----------
+
+        # simple ops with scalars
+        for op in ["__add__", "__sub__", "__truediv__", "__mul__"]:
+            result = getattr(o, op)(1)
+            tm.assert_metadata_equivalent(o, result)
+
+        # ops with like
+        for op in ["__add__", "__sub__", "__truediv__", "__mul__"]:
+            result = getattr(o, op)(o)
+            tm.assert_metadata_equivalent(o, result)
+
+        # simple boolean
+        for op in ["__eq__", "__le__", "__ge__"]:
+            v1 = getattr(o, op)(o)
+            tm.assert_metadata_equivalent(o, v1)
+            tm.assert_metadata_equivalent(o, v1 & v1)
+            tm.assert_metadata_equivalent(o, v1 | v1)
+
+        # combine_first
+        result = o.combine_first(o2)
+        tm.assert_metadata_equivalent(o, result)
+
+        # ---------------------------
+        # non-preserving (by default)
+        # ---------------------------
+
+        # add non-like
+        result = o + o2
+        tm.assert_metadata_equivalent(result)
+
+        # simple boolean
+        for op in ["__eq__", "__le__", "__ge__"]:
+            # this is a name matching op
+            v1 = getattr(o, op)(o)
+            v2 = getattr(o, op)(o2)
+            tm.assert_metadata_equivalent(v2)
+            tm.assert_metadata_equivalent(v1 & v2)
+            tm.assert_metadata_equivalent(v1 | v2)
+
+    def test_size_compat(self, frame_or_series):
+        # GH8846
+        # size property should be defined
+
+        o = construct(frame_or_series, shape=10)
+        assert o.size == np.prod(o.shape)
+        assert o.size == 10 ** len(o.axes)
+
+    def test_split_compat(self, frame_or_series):
+        # xref GH8846
+        o = construct(frame_or_series, shape=10)
+        with tm.assert_produces_warning(
+            FutureWarning, match=".swapaxes' is deprecated", check_stacklevel=False
+        ):
+            assert len(np.array_split(o, 5)) == 5
+            assert len(np.array_split(o, 2)) == 2
+
+    # See gh-12301
+    def test_stat_unexpected_keyword(self, frame_or_series):
+        obj = construct(frame_or_series, 5)
+        starwars = "Star Wars"
+        errmsg = "unexpected keyword"
+
+        with pytest.raises(TypeError, match=errmsg):
+            obj.max(epic=starwars)  # stat_function
+        with pytest.raises(TypeError, match=errmsg):
+            obj.var(epic=starwars)  # stat_function_ddof
+        with pytest.raises(TypeError, match=errmsg):
+            obj.sum(epic=starwars)  # cum_function
+        with pytest.raises(TypeError, match=errmsg):
+            obj.any(epic=starwars)  # logical_function
+
+    @pytest.mark.parametrize("func", ["sum", "cumsum", "any", "var"])
+    def test_api_compat(self, func, frame_or_series):
+        # GH 12021
+        # compat for __name__, __qualname__
+
+        obj = construct(frame_or_series, 5)
+        f = getattr(obj, func)
+        assert f.__name__ == func
+        assert f.__qualname__.endswith(func)
+
+    def test_stat_non_defaults_args(self, frame_or_series):
+        obj = construct(frame_or_series, 5)
+        out = np.array([0])
+        errmsg = "the 'out' parameter is not supported"
+
+        with pytest.raises(ValueError, match=errmsg):
+            obj.max(out=out)  # stat_function
+        with pytest.raises(ValueError, match=errmsg):
+            obj.var(out=out)  # stat_function_ddof
+        with pytest.raises(ValueError, match=errmsg):
+            obj.sum(out=out)  # cum_function
+        with pytest.raises(ValueError, match=errmsg):
+            obj.any(out=out)  # logical_function
+
+    def test_truncate_out_of_bounds(self, frame_or_series):
+        # GH11382
+
+        # small
+        shape = [2000] + ([1] * (frame_or_series._AXIS_LEN - 1))
+        small = construct(frame_or_series, shape, dtype="int8", value=1)
+        tm.assert_equal(small.truncate(), small)
+        tm.assert_equal(small.truncate(before=0, after=3e3), small)
+        tm.assert_equal(small.truncate(before=-1, after=2e3), small)
+
+        # big
+        shape = [2_000_000] + ([1] * (frame_or_series._AXIS_LEN - 1))
+        big = construct(frame_or_series, shape, dtype="int8", value=1)
+        tm.assert_equal(big.truncate(), big)
+        tm.assert_equal(big.truncate(before=0, after=3e6), big)
+        tm.assert_equal(big.truncate(before=-1, after=2e6), big)
+
+    @pytest.mark.parametrize(
+        "func",
+        [copy, deepcopy, lambda x: x.copy(deep=False), lambda x: x.copy(deep=True)],
+    )
+    @pytest.mark.parametrize("shape", [0, 1, 2])
+    def test_copy_and_deepcopy(self, frame_or_series, shape, func):
+        # GH 15444
+        obj = construct(frame_or_series, shape)
+        obj_copy = func(obj)
+        assert obj_copy is not obj
+        tm.assert_equal(obj_copy, obj)
+
+    def test_data_deprecated(self, frame_or_series):
+        obj = frame_or_series()
+        msg = "(Series|DataFrame)._data is deprecated"
+        with tm.assert_produces_warning(DeprecationWarning, match=msg):
+            mgr = obj._data
+        assert mgr is obj._mgr
+
+
+class TestNDFrame:
+    # tests that don't fit elsewhere
+
+    @pytest.mark.parametrize(
+        "ser",
+        [
+            Series(range(10), dtype=np.float64),
+            Series([str(i) for i in range(10)], dtype=object),
+        ],
+    )
+    def test_squeeze_series_noop(self, ser):
+        # noop
+        tm.assert_series_equal(ser.squeeze(), ser)
+
+    def test_squeeze_frame_noop(self):
+        # noop
+        df = DataFrame(np.eye(2))
+        tm.assert_frame_equal(df.squeeze(), df)
+
+    def test_squeeze_frame_reindex(self):
+        # squeezing
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((10, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=date_range("2000-01-01", periods=10, freq="B"),
+        ).reindex(columns=["A"])
+        tm.assert_series_equal(df.squeeze(), df["A"])
+
+    def test_squeeze_0_len_dim(self):
+        # don't fail with 0 length dimensions GH11229 & GH8999
+        empty_series = Series([], name="five", dtype=np.float64)
+        empty_frame = DataFrame([empty_series])
+        tm.assert_series_equal(empty_series, empty_series.squeeze())
+        tm.assert_series_equal(empty_series, empty_frame.squeeze())
+
+    def test_squeeze_axis(self):
+        # axis argument
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((1, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=date_range("2000-01-01", periods=1, freq="B"),
+        ).iloc[:, :1]
+        assert df.shape == (1, 1)
+        tm.assert_series_equal(df.squeeze(axis=0), df.iloc[0])
+        tm.assert_series_equal(df.squeeze(axis="index"), df.iloc[0])
+        tm.assert_series_equal(df.squeeze(axis=1), df.iloc[:, 0])
+        tm.assert_series_equal(df.squeeze(axis="columns"), df.iloc[:, 0])
+        assert df.squeeze() == df.iloc[0, 0]
+        msg = "No axis named 2 for object type DataFrame"
+        with pytest.raises(ValueError, match=msg):
+            df.squeeze(axis=2)
+        msg = "No axis named x for object type DataFrame"
+        with pytest.raises(ValueError, match=msg):
+            df.squeeze(axis="x")
+
+    def test_squeeze_axis_len_3(self):
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((3, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=date_range("2000-01-01", periods=3, freq="B"),
+        )
+        tm.assert_frame_equal(df.squeeze(axis=0), df)
+
+    def test_numpy_squeeze(self):
+        s = Series(range(2), dtype=np.float64)
+        tm.assert_series_equal(np.squeeze(s), s)
+
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((10, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=date_range("2000-01-01", periods=10, freq="B"),
+        ).reindex(columns=["A"])
+        tm.assert_series_equal(np.squeeze(df), df["A"])
+
+    @pytest.mark.parametrize(
+        "ser",
+        [
+            Series(range(10), dtype=np.float64),
+            Series([str(i) for i in range(10)], dtype=object),
+        ],
+    )
+    def test_transpose_series(self, ser):
+        # calls implementation in pandas/core/base.py
+        tm.assert_series_equal(ser.transpose(), ser)
+
+    def test_transpose_frame(self):
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((10, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=date_range("2000-01-01", periods=10, freq="B"),
+        )
+        tm.assert_frame_equal(df.transpose().transpose(), df)
+
+    def test_numpy_transpose(self, frame_or_series):
+        obj = DataFrame(
+            np.random.default_rng(2).standard_normal((10, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=date_range("2000-01-01", periods=10, freq="B"),
+        )
+        obj = tm.get_obj(obj, frame_or_series)
+
+        if frame_or_series is Series:
+            # 1D -> np.transpose is no-op
+            tm.assert_series_equal(np.transpose(obj), obj)
+
+        # round-trip preserved
+        tm.assert_equal(np.transpose(np.transpose(obj)), obj)
+
+        msg = "the 'axes' parameter is not supported"
+        with pytest.raises(ValueError, match=msg):
+            np.transpose(obj, axes=1)
+
+    @pytest.mark.parametrize(
+        "ser",
+        [
+            Series(range(10), dtype=np.float64),
+            Series([str(i) for i in range(10)], dtype=object),
+        ],
+    )
+    def test_take_series(self, ser):
+        indices = [1, 5, -2, 6, 3, -1]
+        out = ser.take(indices)
+        expected = Series(
+            data=ser.values.take(indices),
+            index=ser.index.take(indices),
+            dtype=ser.dtype,
+        )
+        tm.assert_series_equal(out, expected)
+
+    def test_take_frame(self):
+        indices = [1, 5, -2, 6, 3, -1]
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((10, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=date_range("2000-01-01", periods=10, freq="B"),
+        )
+        out = df.take(indices)
+        expected = DataFrame(
+            data=df.values.take(indices, axis=0),
+            index=df.index.take(indices),
+            columns=df.columns,
+        )
+        tm.assert_frame_equal(out, expected)
+
+    def test_take_invalid_kwargs(self, frame_or_series):
+        indices = [-3, 2, 0, 1]
+
+        obj = DataFrame(range(5))
+        obj = tm.get_obj(obj, frame_or_series)
+
+        msg = r"take\(\) got an unexpected keyword argument 'foo'"
+        with pytest.raises(TypeError, match=msg):
+            obj.take(indices, foo=2)
+
+        msg = "the 'out' parameter is not supported"
+        with pytest.raises(ValueError, match=msg):
+            obj.take(indices, out=indices)
+
+        msg = "the 'mode' parameter is not supported"
+        with pytest.raises(ValueError, match=msg):
+            obj.take(indices, mode="clip")
+
+    def test_axis_classmethods(self, frame_or_series):
+        box = frame_or_series
+        obj = box(dtype=object)
+        values = box._AXIS_TO_AXIS_NUMBER.keys()
+        for v in values:
+            assert obj._get_axis_number(v) == box._get_axis_number(v)
+            assert obj._get_axis_name(v) == box._get_axis_name(v)
+            assert obj._get_block_manager_axis(v) == box._get_block_manager_axis(v)
+
+    def test_flags_identity(self, frame_or_series):
+        obj = Series([1, 2])
+        if frame_or_series is DataFrame:
+            obj = obj.to_frame()
+
+        assert obj.flags is obj.flags
+        obj2 = obj.copy()
+        assert obj2.flags is not obj.flags
+
+    def test_bool_dep(self) -> None:
+        # GH-51749
+        msg_warn = (
+            "DataFrame.bool is now deprecated and will be removed "
+            "in future version of pandas"
+        )
+        with tm.assert_produces_warning(FutureWarning, match=msg_warn):
+            DataFrame({"col": [False]}).bool()

venv/lib/python3.10/site-packages/pandas/tests/generic/test_label_or_level_utils.py

@@ -0,0 +1,336 @@
+import pytest
+
+from pandas.core.dtypes.missing import array_equivalent
+
+import pandas as pd
+
+
+# Fixtures
+# ========
+@pytest.fixture
+def df():
+    """DataFrame with columns 'L1', 'L2', and 'L3'"""
+    return pd.DataFrame({"L1": [1, 2, 3], "L2": [11, 12, 13], "L3": ["A", "B", "C"]})
+
+
+@pytest.fixture(params=[[], ["L1"], ["L1", "L2"], ["L1", "L2", "L3"]])
+def df_levels(request, df):
+    """DataFrame with columns or index levels 'L1', 'L2', and 'L3'"""
+    levels = request.param
+
+    if levels:
+        df = df.set_index(levels)
+
+    return df
+
+
+@pytest.fixture
+def df_ambig(df):
+    """DataFrame with levels 'L1' and 'L2' and labels 'L1' and 'L3'"""
+    df = df.set_index(["L1", "L2"])
+
+    df["L1"] = df["L3"]
+
+    return df
+
+
+@pytest.fixture
+def df_duplabels(df):
+    """DataFrame with level 'L1' and labels 'L2', 'L3', and 'L2'"""
+    df = df.set_index(["L1"])
+    df = pd.concat([df, df["L2"]], axis=1)
+
+    return df
+
+
+# Test is label/level reference
+# =============================
+def get_labels_levels(df_levels):
+    expected_labels = list(df_levels.columns)
+    expected_levels = [name for name in df_levels.index.names if name is not None]
+    return expected_labels, expected_levels
+
+
+def assert_label_reference(frame, labels, axis):
+    for label in labels:
+        assert frame._is_label_reference(label, axis=axis)
+        assert not frame._is_level_reference(label, axis=axis)
+        assert frame._is_label_or_level_reference(label, axis=axis)
+
+
+def assert_level_reference(frame, levels, axis):
+    for level in levels:
+        assert frame._is_level_reference(level, axis=axis)
+        assert not frame._is_label_reference(level, axis=axis)
+        assert frame._is_label_or_level_reference(level, axis=axis)
+
+
+# DataFrame
+# ---------
+def test_is_level_or_label_reference_df_simple(df_levels, axis):
+    axis = df_levels._get_axis_number(axis)
+    # Compute expected labels and levels
+    expected_labels, expected_levels = get_labels_levels(df_levels)
+
+    # Transpose frame if axis == 1
+    if axis == 1:
+        df_levels = df_levels.T
+
+    # Perform checks
+    assert_level_reference(df_levels, expected_levels, axis=axis)
+    assert_label_reference(df_levels, expected_labels, axis=axis)
+
+
+def test_is_level_reference_df_ambig(df_ambig, axis):
+    axis = df_ambig._get_axis_number(axis)
+
+    # Transpose frame if axis == 1
+    if axis == 1:
+        df_ambig = df_ambig.T
+
+    # df has both an on-axis level and off-axis label named L1
+    # Therefore L1 should reference the label, not the level
+    assert_label_reference(df_ambig, ["L1"], axis=axis)
+
+    # df has an on-axis level named L2 and it is not ambiguous
+    # Therefore L2 is an level reference
+    assert_level_reference(df_ambig, ["L2"], axis=axis)
+
+    # df has a column named L3 and it not an level reference
+    assert_label_reference(df_ambig, ["L3"], axis=axis)
+
+
+# Series
+# ------
+def test_is_level_reference_series_simple_axis0(df):
+    # Make series with L1 as index
+    s = df.set_index("L1").L2
+    assert_level_reference(s, ["L1"], axis=0)
+    assert not s._is_level_reference("L2")
+
+    # Make series with L1 and L2 as index
+    s = df.set_index(["L1", "L2"]).L3
+    assert_level_reference(s, ["L1", "L2"], axis=0)
+    assert not s._is_level_reference("L3")
+
+
+def test_is_level_reference_series_axis1_error(df):
+    # Make series with L1 as index
+    s = df.set_index("L1").L2
+
+    with pytest.raises(ValueError, match="No axis named 1"):
+        s._is_level_reference("L1", axis=1)
+
+
+# Test _check_label_or_level_ambiguity_df
+# =======================================
+
+
+# DataFrame
+# ---------
+def test_check_label_or_level_ambiguity_df(df_ambig, axis):
+    axis = df_ambig._get_axis_number(axis)
+    # Transpose frame if axis == 1
+    if axis == 1:
+        df_ambig = df_ambig.T
+        msg = "'L1' is both a column level and an index label"
+
+    else:
+        msg = "'L1' is both an index level and a column label"
+    # df_ambig has both an on-axis level and off-axis label named L1
+    # Therefore, L1 is ambiguous.
+    with pytest.raises(ValueError, match=msg):
+        df_ambig._check_label_or_level_ambiguity("L1", axis=axis)
+
+    # df_ambig has an on-axis level named L2,, and it is not ambiguous.
+    df_ambig._check_label_or_level_ambiguity("L2", axis=axis)
+
+    # df_ambig has an off-axis label named L3, and it is not ambiguous
+    assert not df_ambig._check_label_or_level_ambiguity("L3", axis=axis)
+
+
+# Series
+# ------
+def test_check_label_or_level_ambiguity_series(df):
+    # A series has no columns and therefore references are never ambiguous
+
+    # Make series with L1 as index
+    s = df.set_index("L1").L2
+    s._check_label_or_level_ambiguity("L1", axis=0)
+    s._check_label_or_level_ambiguity("L2", axis=0)
+
+    # Make series with L1 and L2 as index
+    s = df.set_index(["L1", "L2"]).L3
+    s._check_label_or_level_ambiguity("L1", axis=0)
+    s._check_label_or_level_ambiguity("L2", axis=0)
+    s._check_label_or_level_ambiguity("L3", axis=0)
+
+
+def test_check_label_or_level_ambiguity_series_axis1_error(df):
+    # Make series with L1 as index
+    s = df.set_index("L1").L2
+
+    with pytest.raises(ValueError, match="No axis named 1"):
+        s._check_label_or_level_ambiguity("L1", axis=1)
+
+
+# Test _get_label_or_level_values
+# ===============================
+def assert_label_values(frame, labels, axis):
+    axis = frame._get_axis_number(axis)
+    for label in labels:
+        if axis == 0:
+            expected = frame[label]._values
+        else:
+            expected = frame.loc[label]._values
+
+        result = frame._get_label_or_level_values(label, axis=axis)
+        assert array_equivalent(expected, result)
+
+
+def assert_level_values(frame, levels, axis):
+    axis = frame._get_axis_number(axis)
+    for level in levels:
+        if axis == 0:
+            expected = frame.index.get_level_values(level=level)._values
+        else:
+            expected = frame.columns.get_level_values(level=level)._values
+
+        result = frame._get_label_or_level_values(level, axis=axis)
+        assert array_equivalent(expected, result)
+
+
+# DataFrame
+# ---------
+def test_get_label_or_level_values_df_simple(df_levels, axis):
+    # Compute expected labels and levels
+    expected_labels, expected_levels = get_labels_levels(df_levels)
+
+    axis = df_levels._get_axis_number(axis)
+    # Transpose frame if axis == 1
+    if axis == 1:
+        df_levels = df_levels.T
+
+    # Perform checks
+    assert_label_values(df_levels, expected_labels, axis=axis)
+    assert_level_values(df_levels, expected_levels, axis=axis)
+
+
+def test_get_label_or_level_values_df_ambig(df_ambig, axis):
+    axis = df_ambig._get_axis_number(axis)
+    # Transpose frame if axis == 1
+    if axis == 1:
+        df_ambig = df_ambig.T
+
+    # df has an on-axis level named L2, and it is not ambiguous.
+    assert_level_values(df_ambig, ["L2"], axis=axis)
+
+    # df has an off-axis label named L3, and it is not ambiguous.
+    assert_label_values(df_ambig, ["L3"], axis=axis)
+
+
+def test_get_label_or_level_values_df_duplabels(df_duplabels, axis):
+    axis = df_duplabels._get_axis_number(axis)
+    # Transpose frame if axis == 1
+    if axis == 1:
+        df_duplabels = df_duplabels.T
+
+    # df has unambiguous level 'L1'
+    assert_level_values(df_duplabels, ["L1"], axis=axis)
+
+    # df has unique label 'L3'
+    assert_label_values(df_duplabels, ["L3"], axis=axis)
+
+    # df has duplicate labels 'L2'
+    if axis == 0:
+        expected_msg = "The column label 'L2' is not unique"
+    else:
+        expected_msg = "The index label 'L2' is not unique"
+
+    with pytest.raises(ValueError, match=expected_msg):
+        assert_label_values(df_duplabels, ["L2"], axis=axis)
+
+
+# Series
+# ------
+def test_get_label_or_level_values_series_axis0(df):
+    # Make series with L1 as index
+    s = df.set_index("L1").L2
+    assert_level_values(s, ["L1"], axis=0)
+
+    # Make series with L1 and L2 as index
+    s = df.set_index(["L1", "L2"]).L3
+    assert_level_values(s, ["L1", "L2"], axis=0)
+
+
+def test_get_label_or_level_values_series_axis1_error(df):
+    # Make series with L1 as index
+    s = df.set_index("L1").L2
+
+    with pytest.raises(ValueError, match="No axis named 1"):
+        s._get_label_or_level_values("L1", axis=1)
+
+
+# Test _drop_labels_or_levels
+# ===========================
+def assert_labels_dropped(frame, labels, axis):
+    axis = frame._get_axis_number(axis)
+    for label in labels:
+        df_dropped = frame._drop_labels_or_levels(label, axis=axis)
+
+        if axis == 0:
+            assert label in frame.columns
+            assert label not in df_dropped.columns
+        else:
+            assert label in frame.index
+            assert label not in df_dropped.index
+
+
+def assert_levels_dropped(frame, levels, axis):
+    axis = frame._get_axis_number(axis)
+    for level in levels:
+        df_dropped = frame._drop_labels_or_levels(level, axis=axis)
+
+        if axis == 0:
+            assert level in frame.index.names
+            assert level not in df_dropped.index.names
+        else:
+            assert level in frame.columns.names
+            assert level not in df_dropped.columns.names
+
+
+# DataFrame
+# ---------
+def test_drop_labels_or_levels_df(df_levels, axis):
+    # Compute expected labels and levels
+    expected_labels, expected_levels = get_labels_levels(df_levels)
+
+    axis = df_levels._get_axis_number(axis)
+    # Transpose frame if axis == 1
+    if axis == 1:
+        df_levels = df_levels.T
+
+    # Perform checks
+    assert_labels_dropped(df_levels, expected_labels, axis=axis)
+    assert_levels_dropped(df_levels, expected_levels, axis=axis)
+
+    with pytest.raises(ValueError, match="not valid labels or levels"):
+        df_levels._drop_labels_or_levels("L4", axis=axis)
+
+
+# Series
+# ------
+def test_drop_labels_or_levels_series(df):
+    # Make series with L1 as index
+    s = df.set_index("L1").L2
+    assert_levels_dropped(s, ["L1"], axis=0)
+
+    with pytest.raises(ValueError, match="not valid labels or levels"):
+        s._drop_labels_or_levels("L4", axis=0)
+
+    # Make series with L1 and L2 as index
+    s = df.set_index(["L1", "L2"]).L3
+    assert_levels_dropped(s, ["L1", "L2"], axis=0)
+
+    with pytest.raises(ValueError, match="not valid labels or levels"):
+        s._drop_labels_or_levels("L4", axis=0)

venv/lib/python3.10/site-packages/pandas/tests/generic/test_series.py

@@ -0,0 +1,159 @@
+from operator import methodcaller
+
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    MultiIndex,
+    Series,
+    date_range,
+)
+import pandas._testing as tm
+
+
+class TestSeries:
+    @pytest.mark.parametrize("func", ["rename_axis", "_set_axis_name"])
+    def test_set_axis_name_mi(self, func):
+        ser = Series(
+            [11, 21, 31],
+            index=MultiIndex.from_tuples(
+                [("A", x) for x in ["a", "B", "c"]], names=["l1", "l2"]
+            ),
+        )
+
+        result = methodcaller(func, ["L1", "L2"])(ser)
+        assert ser.index.name is None
+        assert ser.index.names == ["l1", "l2"]
+        assert result.index.name is None
+        assert result.index.names, ["L1", "L2"]
+
+    def test_set_axis_name_raises(self):
+        ser = Series([1])
+        msg = "No axis named 1 for object type Series"
+        with pytest.raises(ValueError, match=msg):
+            ser._set_axis_name(name="a", axis=1)
+
+    def test_get_bool_data_preserve_dtype(self):
+        ser = Series([True, False, True])
+        result = ser._get_bool_data()
+        tm.assert_series_equal(result, ser)
+
+    def test_nonzero_single_element(self):
+        # allow single item via bool method
+        msg_warn = (
+            "Series.bool is now deprecated and will be removed "
+            "in future version of pandas"
+        )
+        ser = Series([True])
+        ser1 = Series([False])
+        with tm.assert_produces_warning(FutureWarning, match=msg_warn):
+            assert ser.bool()
+        with tm.assert_produces_warning(FutureWarning, match=msg_warn):
+            assert not ser1.bool()
+
+    @pytest.mark.parametrize("data", [np.nan, pd.NaT, True, False])
+    def test_nonzero_single_element_raise_1(self, data):
+        # single item nan to raise
+        series = Series([data])
+
+        msg = "The truth value of a Series is ambiguous"
+        with pytest.raises(ValueError, match=msg):
+            bool(series)
+
+    @pytest.mark.parametrize("data", [np.nan, pd.NaT])
+    def test_nonzero_single_element_raise_2(self, data):
+        msg_warn = (
+            "Series.bool is now deprecated and will be removed "
+            "in future version of pandas"
+        )
+        msg_err = "bool cannot act on a non-boolean single element Series"
+        series = Series([data])
+        with tm.assert_produces_warning(FutureWarning, match=msg_warn):
+            with pytest.raises(ValueError, match=msg_err):
+                series.bool()
+
+    @pytest.mark.parametrize("data", [(True, True), (False, False)])
+    def test_nonzero_multiple_element_raise(self, data):
+        # multiple bool are still an error
+        msg_warn = (
+            "Series.bool is now deprecated and will be removed "
+            "in future version of pandas"
+        )
+        msg_err = "The truth value of a Series is ambiguous"
+        series = Series([data])
+        with pytest.raises(ValueError, match=msg_err):
+            bool(series)
+        with tm.assert_produces_warning(FutureWarning, match=msg_warn):
+            with pytest.raises(ValueError, match=msg_err):
+                series.bool()
+
+    @pytest.mark.parametrize("data", [1, 0, "a", 0.0])
+    def test_nonbool_single_element_raise(self, data):
+        # single non-bool are an error
+        msg_warn = (
+            "Series.bool is now deprecated and will be removed "
+            "in future version of pandas"
+        )
+        msg_err1 = "The truth value of a Series is ambiguous"
+        msg_err2 = "bool cannot act on a non-boolean single element Series"
+        series = Series([data])
+        with pytest.raises(ValueError, match=msg_err1):
+            bool(series)
+        with tm.assert_produces_warning(FutureWarning, match=msg_warn):
+            with pytest.raises(ValueError, match=msg_err2):
+                series.bool()
+
+    def test_metadata_propagation_indiv_resample(self):
+        # resample
+        ts = Series(
+            np.random.default_rng(2).random(1000),
+            index=date_range("20130101", periods=1000, freq="s"),
+            name="foo",
+        )
+        result = ts.resample("1min").mean()
+        tm.assert_metadata_equivalent(ts, result)
+
+        result = ts.resample("1min").min()
+        tm.assert_metadata_equivalent(ts, result)
+
+        result = ts.resample("1min").apply(lambda x: x.sum())
+        tm.assert_metadata_equivalent(ts, result)
+
+    def test_metadata_propagation_indiv(self, monkeypatch):
+        # check that the metadata matches up on the resulting ops
+
+        ser = Series(range(3), range(3))
+        ser.name = "foo"
+        ser2 = Series(range(3), range(3))
+        ser2.name = "bar"
+
+        result = ser.T
+        tm.assert_metadata_equivalent(ser, result)
+
+        def finalize(self, other, method=None, **kwargs):
+            for name in self._metadata:
+                if method == "concat" and name == "filename":
+                    value = "+".join(
+                        [
+                            getattr(obj, name)
+                            for obj in other.objs
+                            if getattr(obj, name, None)
+                        ]
+                    )
+                    object.__setattr__(self, name, value)
+                else:
+                    object.__setattr__(self, name, getattr(other, name, None))
+
+            return self
+
+        with monkeypatch.context() as m:
+            m.setattr(Series, "_metadata", ["name", "filename"])
+            m.setattr(Series, "__finalize__", finalize)
+
+            ser.filename = "foo"
+            ser2.filename = "bar"
+
+            result = pd.concat([ser, ser2])
+            assert result.filename == "foo+bar"
+            assert result.name is None

venv/lib/python3.10/site-packages/pandas/tests/generic/test_to_xarray.py

@@ -0,0 +1,130 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    Categorical,
+    DataFrame,
+    MultiIndex,
+    Series,
+    date_range,
+)
+import pandas._testing as tm
+
+pytest.importorskip("xarray")
+
+
+class TestDataFrameToXArray:
+    @pytest.fixture
+    def df(self):
+        return DataFrame(
+            {
+                "a": list("abcd"),
+                "b": list(range(1, 5)),
+                "c": np.arange(3, 7).astype("u1"),
+                "d": np.arange(4.0, 8.0, dtype="float64"),
+                "e": [True, False, True, False],
+                "f": Categorical(list("abcd")),
+                "g": date_range("20130101", periods=4),
+                "h": date_range("20130101", periods=4, tz="US/Eastern"),
+            }
+        )
+
+    def test_to_xarray_index_types(self, index_flat, df, using_infer_string):
+        index = index_flat
+        # MultiIndex is tested in test_to_xarray_with_multiindex
+        if len(index) == 0:
+            pytest.skip("Test doesn't make sense for empty index")
+
+        from xarray import Dataset
+
+        df.index = index[:4]
+        df.index.name = "foo"
+        df.columns.name = "bar"
+        result = df.to_xarray()
+        assert result.sizes["foo"] == 4
+        assert len(result.coords) == 1
+        assert len(result.data_vars) == 8
+        tm.assert_almost_equal(list(result.coords.keys()), ["foo"])
+        assert isinstance(result, Dataset)
+
+        # idempotency
+        # datetimes w/tz are preserved
+        # column names are lost
+        expected = df.copy()
+        expected["f"] = expected["f"].astype(
+            object if not using_infer_string else "string[pyarrow_numpy]"
+        )
+        expected.columns.name = None
+        tm.assert_frame_equal(result.to_dataframe(), expected)
+
+    def test_to_xarray_empty(self, df):
+        from xarray import Dataset
+
+        df.index.name = "foo"
+        result = df[0:0].to_xarray()
+        assert result.sizes["foo"] == 0
+        assert isinstance(result, Dataset)
+
+    def test_to_xarray_with_multiindex(self, df, using_infer_string):
+        from xarray import Dataset
+
+        # MultiIndex
+        df.index = MultiIndex.from_product([["a"], range(4)], names=["one", "two"])
+        result = df.to_xarray()
+        assert result.sizes["one"] == 1
+        assert result.sizes["two"] == 4
+        assert len(result.coords) == 2
+        assert len(result.data_vars) == 8
+        tm.assert_almost_equal(list(result.coords.keys()), ["one", "two"])
+        assert isinstance(result, Dataset)
+
+        result = result.to_dataframe()
+        expected = df.copy()
+        expected["f"] = expected["f"].astype(
+            object if not using_infer_string else "string[pyarrow_numpy]"
+        )
+        expected.columns.name = None
+        tm.assert_frame_equal(result, expected)
+
+
+class TestSeriesToXArray:
+    def test_to_xarray_index_types(self, index_flat):
+        index = index_flat
+        # MultiIndex is tested in test_to_xarray_with_multiindex
+
+        from xarray import DataArray
+
+        ser = Series(range(len(index)), index=index, dtype="int64")
+        ser.index.name = "foo"
+        result = ser.to_xarray()
+        repr(result)
+        assert len(result) == len(index)
+        assert len(result.coords) == 1
+        tm.assert_almost_equal(list(result.coords.keys()), ["foo"])
+        assert isinstance(result, DataArray)
+
+        # idempotency
+        tm.assert_series_equal(result.to_series(), ser)
+
+    def test_to_xarray_empty(self):
+        from xarray import DataArray
+
+        ser = Series([], dtype=object)
+        ser.index.name = "foo"
+        result = ser.to_xarray()
+        assert len(result) == 0
+        assert len(result.coords) == 1
+        tm.assert_almost_equal(list(result.coords.keys()), ["foo"])
+        assert isinstance(result, DataArray)
+
+    def test_to_xarray_with_multiindex(self):
+        from xarray import DataArray
+
+        mi = MultiIndex.from_product([["a", "b"], range(3)], names=["one", "two"])
+        ser = Series(range(6), dtype="int64", index=mi)
+        result = ser.to_xarray()
+        assert len(result) == 2
+        tm.assert_almost_equal(list(result.coords.keys()), ["one", "two"])
+        assert isinstance(result, DataArray)
+        res = result.to_series()
+        tm.assert_series_equal(res, ser)