Add files using upload-large-folder tool

ckpts/universal/global_step80/zero/29.vocab_parallel_projection.weight/exp_avg.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9d3809ad4f4093105a7755bf0762809537b7f61f2f619bf7c249a15b71b97657
+size 415237276

ckpts/universal/global_step80/zero/29.vocab_parallel_projection.weight/fp32.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:94d6106a37347803a51c41c9c7ddad11335ae199d032aa8c1365b03c2a38348b
+size 415237197

venv/lib/python3.10/site-packages/pandas/tests/arrays/boolean/test_arithmetic.py

@@ -0,0 +1,139 @@
+import operator
+
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+
+
+@pytest.fixture
+def data():
+    """Fixture returning boolean array with valid and missing values."""
+    return pd.array(
+        [True, False] * 4 + [np.nan] + [True, False] * 44 + [np.nan] + [True, False],
+        dtype="boolean",
+    )
+
+
+@pytest.fixture
+def left_array():
+    """Fixture returning boolean array with valid and missing values."""
+    return pd.array([True] * 3 + [False] * 3 + [None] * 3, dtype="boolean")
+
+
+@pytest.fixture
+def right_array():
+    """Fixture returning boolean array with valid and missing values."""
+    return pd.array([True, False, None] * 3, dtype="boolean")
+
+
+# Basic test for the arithmetic array ops
+# -----------------------------------------------------------------------------
+
+
+@pytest.mark.parametrize(
+    "opname, exp",
+    [
+        ("add", [True, True, None, True, False, None, None, None, None]),
+        ("mul", [True, False, None, False, False, None, None, None, None]),
+    ],
+    ids=["add", "mul"],
+)
+def test_add_mul(left_array, right_array, opname, exp):
+    op = getattr(operator, opname)
+    result = op(left_array, right_array)
+    expected = pd.array(exp, dtype="boolean")
+    tm.assert_extension_array_equal(result, expected)
+
+
+def test_sub(left_array, right_array):
+    msg = (
+        r"numpy boolean subtract, the `-` operator, is (?:deprecated|not supported), "
+        r"use the bitwise_xor, the `\^` operator, or the logical_xor function instead\."
+    )
+    with pytest.raises(TypeError, match=msg):
+        left_array - right_array
+
+
+def test_div(left_array, right_array):
+    msg = "operator '.*' not implemented for bool dtypes"
+    with pytest.raises(NotImplementedError, match=msg):
+        # check that we are matching the non-masked Series behavior
+        pd.Series(left_array._data) / pd.Series(right_array._data)
+
+    with pytest.raises(NotImplementedError, match=msg):
+        left_array / right_array
+
+
+@pytest.mark.parametrize(
+    "opname",
+    [
+        "floordiv",
+        "mod",
+        "pow",
+    ],
+)
+def test_op_int8(left_array, right_array, opname):
+    op = getattr(operator, opname)
+    if opname != "mod":
+        msg = "operator '.*' not implemented for bool dtypes"
+        with pytest.raises(NotImplementedError, match=msg):
+            result = op(left_array, right_array)
+        return
+    result = op(left_array, right_array)
+    expected = op(left_array.astype("Int8"), right_array.astype("Int8"))
+    tm.assert_extension_array_equal(result, expected)
+
+
+# Test generic characteristics / errors
+# -----------------------------------------------------------------------------
+
+
+def test_error_invalid_values(data, all_arithmetic_operators, using_infer_string):
+    # invalid ops
+
+    if using_infer_string:
+        import pyarrow as pa
+
+        err = (TypeError, pa.lib.ArrowNotImplementedError, NotImplementedError)
+    else:
+        err = TypeError
+
+    op = all_arithmetic_operators
+    s = pd.Series(data)
+    ops = getattr(s, op)
+
+    # invalid scalars
+    msg = (
+        "did not contain a loop with signature matching types|"
+        "BooleanArray cannot perform the operation|"
+        "not supported for the input types, and the inputs could not be safely coerced "
+        "to any supported types according to the casting rule ''safe''"
+    )
+    with pytest.raises(TypeError, match=msg):
+        ops("foo")
+    msg = "|".join(
+        [
+            r"unsupported operand type\(s\) for",
+            "Concatenation operation is not implemented for NumPy arrays",
+            "has no kernel",
+        ]
+    )
+    with pytest.raises(err, match=msg):
+        ops(pd.Timestamp("20180101"))
+
+    # invalid array-likes
+    if op not in ("__mul__", "__rmul__"):
+        # TODO(extension) numpy's mul with object array sees booleans as numbers
+        msg = "|".join(
+            [
+                r"unsupported operand type\(s\) for",
+                "can only concatenate str",
+                "not all arguments converted during string formatting",
+                "has no kernel",
+                "not implemented",
+            ]
+        )
+        with pytest.raises(err, match=msg):
+            ops(pd.Series("foo", index=s.index))

venv/lib/python3.10/site-packages/pandas/tests/arrays/boolean/test_astype.py

@@ -0,0 +1,53 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+
+
+def test_astype():
+    # with missing values
+    arr = pd.array([True, False, None], dtype="boolean")
+
+    with pytest.raises(ValueError, match="cannot convert NA to integer"):
+        arr.astype("int64")
+
+    with pytest.raises(ValueError, match="cannot convert float NaN to"):
+        arr.astype("bool")
+
+    result = arr.astype("float64")
+    expected = np.array([1, 0, np.nan], dtype="float64")
+    tm.assert_numpy_array_equal(result, expected)
+
+    result = arr.astype("str")
+    expected = np.array(["True", "False", "<NA>"], dtype=f"{tm.ENDIAN}U5")
+    tm.assert_numpy_array_equal(result, expected)
+
+    # no missing values
+    arr = pd.array([True, False, True], dtype="boolean")
+    result = arr.astype("int64")
+    expected = np.array([1, 0, 1], dtype="int64")
+    tm.assert_numpy_array_equal(result, expected)
+
+    result = arr.astype("bool")
+    expected = np.array([True, False, True], dtype="bool")
+    tm.assert_numpy_array_equal(result, expected)
+
+
+def test_astype_to_boolean_array():
+    # astype to BooleanArray
+    arr = pd.array([True, False, None], dtype="boolean")
+
+    result = arr.astype("boolean")
+    tm.assert_extension_array_equal(result, arr)
+    result = arr.astype(pd.BooleanDtype())
+    tm.assert_extension_array_equal(result, arr)
+
+
+def test_astype_to_integer_array():
+    # astype to IntegerArray
+    arr = pd.array([True, False, None], dtype="boolean")
+
+    result = arr.astype("Int64")
+    expected = pd.array([1, 0, None], dtype="Int64")
+    tm.assert_extension_array_equal(result, expected)

venv/lib/python3.10/site-packages/pandas/tests/arrays/boolean/test_comparison.py

@@ -0,0 +1,60 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+from pandas.arrays import BooleanArray
+from pandas.tests.arrays.masked_shared import ComparisonOps
+
+
+@pytest.fixture
+def data():
+    """Fixture returning boolean array with valid and missing data"""
+    return pd.array(
+        [True, False] * 4 + [np.nan] + [True, False] * 44 + [np.nan] + [True, False],
+        dtype="boolean",
+    )
+
+
+@pytest.fixture
+def dtype():
+    """Fixture returning BooleanDtype"""
+    return pd.BooleanDtype()
+
+
+class TestComparisonOps(ComparisonOps):
+    def test_compare_scalar(self, data, comparison_op):
+        self._compare_other(data, comparison_op, True)
+
+    def test_compare_array(self, data, comparison_op):
+        other = pd.array([True] * len(data), dtype="boolean")
+        self._compare_other(data, comparison_op, other)
+        other = np.array([True] * len(data))
+        self._compare_other(data, comparison_op, other)
+        other = pd.Series([True] * len(data))
+        self._compare_other(data, comparison_op, other)
+
+    @pytest.mark.parametrize("other", [True, False, pd.NA])
+    def test_scalar(self, other, comparison_op, dtype):
+        ComparisonOps.test_scalar(self, other, comparison_op, dtype)
+
+    def test_array(self, comparison_op):
+        op = comparison_op
+        a = pd.array([True] * 3 + [False] * 3 + [None] * 3, dtype="boolean")
+        b = pd.array([True, False, None] * 3, dtype="boolean")
+
+        result = op(a, b)
+
+        values = op(a._data, b._data)
+        mask = a._mask | b._mask
+        expected = BooleanArray(values, mask)
+        tm.assert_extension_array_equal(result, expected)
+
+        # ensure we haven't mutated anything inplace
+        result[0] = None
+        tm.assert_extension_array_equal(
+            a, pd.array([True] * 3 + [False] * 3 + [None] * 3, dtype="boolean")
+        )
+        tm.assert_extension_array_equal(
+            b, pd.array([True, False, None] * 3, dtype="boolean")
+        )

venv/lib/python3.10/site-packages/pandas/tests/arrays/boolean/test_construction.py

@@ -0,0 +1,325 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+from pandas.arrays import BooleanArray
+from pandas.core.arrays.boolean import coerce_to_array
+
+
+def test_boolean_array_constructor():
+    values = np.array([True, False, True, False], dtype="bool")
+    mask = np.array([False, False, False, True], dtype="bool")
+
+    result = BooleanArray(values, mask)
+    expected = pd.array([True, False, True, None], dtype="boolean")
+    tm.assert_extension_array_equal(result, expected)
+
+    with pytest.raises(TypeError, match="values should be boolean numpy array"):
+        BooleanArray(values.tolist(), mask)
+
+    with pytest.raises(TypeError, match="mask should be boolean numpy array"):
+        BooleanArray(values, mask.tolist())
+
+    with pytest.raises(TypeError, match="values should be boolean numpy array"):
+        BooleanArray(values.astype(int), mask)
+
+    with pytest.raises(TypeError, match="mask should be boolean numpy array"):
+        BooleanArray(values, None)
+
+    with pytest.raises(ValueError, match="values.shape must match mask.shape"):
+        BooleanArray(values.reshape(1, -1), mask)
+
+    with pytest.raises(ValueError, match="values.shape must match mask.shape"):
+        BooleanArray(values, mask.reshape(1, -1))
+
+
+def test_boolean_array_constructor_copy():
+    values = np.array([True, False, True, False], dtype="bool")
+    mask = np.array([False, False, False, True], dtype="bool")
+
+    result = BooleanArray(values, mask)
+    assert result._data is values
+    assert result._mask is mask
+
+    result = BooleanArray(values, mask, copy=True)
+    assert result._data is not values
+    assert result._mask is not mask
+
+
+def test_to_boolean_array():
+    expected = BooleanArray(
+        np.array([True, False, True]), np.array([False, False, False])
+    )
+
+    result = pd.array([True, False, True], dtype="boolean")
+    tm.assert_extension_array_equal(result, expected)
+    result = pd.array(np.array([True, False, True]), dtype="boolean")
+    tm.assert_extension_array_equal(result, expected)
+    result = pd.array(np.array([True, False, True], dtype=object), dtype="boolean")
+    tm.assert_extension_array_equal(result, expected)
+
+    # with missing values
+    expected = BooleanArray(
+        np.array([True, False, True]), np.array([False, False, True])
+    )
+
+    result = pd.array([True, False, None], dtype="boolean")
+    tm.assert_extension_array_equal(result, expected)
+    result = pd.array(np.array([True, False, None], dtype=object), dtype="boolean")
+    tm.assert_extension_array_equal(result, expected)
+
+
+def test_to_boolean_array_all_none():
+    expected = BooleanArray(np.array([True, True, True]), np.array([True, True, True]))
+
+    result = pd.array([None, None, None], dtype="boolean")
+    tm.assert_extension_array_equal(result, expected)
+    result = pd.array(np.array([None, None, None], dtype=object), dtype="boolean")
+    tm.assert_extension_array_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "a, b",
+    [
+        ([True, False, None, np.nan, pd.NA], [True, False, None, None, None]),
+        ([True, np.nan], [True, None]),
+        ([True, pd.NA], [True, None]),
+        ([np.nan, np.nan], [None, None]),
+        (np.array([np.nan, np.nan], dtype=float), [None, None]),
+    ],
+)
+def test_to_boolean_array_missing_indicators(a, b):
+    result = pd.array(a, dtype="boolean")
+    expected = pd.array(b, dtype="boolean")
+    tm.assert_extension_array_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "values",
+    [
+        ["foo", "bar"],
+        ["1", "2"],
+        # "foo",
+        [1, 2],
+        [1.0, 2.0],
+        pd.date_range("20130101", periods=2),
+        np.array(["foo"]),
+        np.array([1, 2]),
+        np.array([1.0, 2.0]),
+        [np.nan, {"a": 1}],
+    ],
+)
+def test_to_boolean_array_error(values):
+    # error in converting existing arrays to BooleanArray
+    msg = "Need to pass bool-like value"
+    with pytest.raises(TypeError, match=msg):
+        pd.array(values, dtype="boolean")
+
+
+def test_to_boolean_array_from_integer_array():
+    result = pd.array(np.array([1, 0, 1, 0]), dtype="boolean")
+    expected = pd.array([True, False, True, False], dtype="boolean")
+    tm.assert_extension_array_equal(result, expected)
+
+    # with missing values
+    result = pd.array(np.array([1, 0, 1, None]), dtype="boolean")
+    expected = pd.array([True, False, True, None], dtype="boolean")
+    tm.assert_extension_array_equal(result, expected)
+
+
+def test_to_boolean_array_from_float_array():
+    result = pd.array(np.array([1.0, 0.0, 1.0, 0.0]), dtype="boolean")
+    expected = pd.array([True, False, True, False], dtype="boolean")
+    tm.assert_extension_array_equal(result, expected)
+
+    # with missing values
+    result = pd.array(np.array([1.0, 0.0, 1.0, np.nan]), dtype="boolean")
+    expected = pd.array([True, False, True, None], dtype="boolean")
+    tm.assert_extension_array_equal(result, expected)
+
+
+def test_to_boolean_array_integer_like():
+    # integers of 0's and 1's
+    result = pd.array([1, 0, 1, 0], dtype="boolean")
+    expected = pd.array([True, False, True, False], dtype="boolean")
+    tm.assert_extension_array_equal(result, expected)
+
+    # with missing values
+    result = pd.array([1, 0, 1, None], dtype="boolean")
+    expected = pd.array([True, False, True, None], dtype="boolean")
+    tm.assert_extension_array_equal(result, expected)
+
+
+def test_coerce_to_array():
+    # TODO this is currently not public API
+    values = np.array([True, False, True, False], dtype="bool")
+    mask = np.array([False, False, False, True], dtype="bool")
+    result = BooleanArray(*coerce_to_array(values, mask=mask))
+    expected = BooleanArray(values, mask)
+    tm.assert_extension_array_equal(result, expected)
+    assert result._data is values
+    assert result._mask is mask
+    result = BooleanArray(*coerce_to_array(values, mask=mask, copy=True))
+    expected = BooleanArray(values, mask)
+    tm.assert_extension_array_equal(result, expected)
+    assert result._data is not values
+    assert result._mask is not mask
+
+    # mixed missing from values and mask
+    values = [True, False, None, False]
+    mask = np.array([False, False, False, True], dtype="bool")
+    result = BooleanArray(*coerce_to_array(values, mask=mask))
+    expected = BooleanArray(
+        np.array([True, False, True, True]), np.array([False, False, True, True])
+    )
+    tm.assert_extension_array_equal(result, expected)
+    result = BooleanArray(*coerce_to_array(np.array(values, dtype=object), mask=mask))
+    tm.assert_extension_array_equal(result, expected)
+    result = BooleanArray(*coerce_to_array(values, mask=mask.tolist()))
+    tm.assert_extension_array_equal(result, expected)
+
+    # raise errors for wrong dimension
+    values = np.array([True, False, True, False], dtype="bool")
+    mask = np.array([False, False, False, True], dtype="bool")
+
+    # passing 2D values is OK as long as no mask
+    coerce_to_array(values.reshape(1, -1))
+
+    with pytest.raises(ValueError, match="values.shape and mask.shape must match"):
+        coerce_to_array(values.reshape(1, -1), mask=mask)
+
+    with pytest.raises(ValueError, match="values.shape and mask.shape must match"):
+        coerce_to_array(values, mask=mask.reshape(1, -1))
+
+
+def test_coerce_to_array_from_boolean_array():
+    # passing BooleanArray to coerce_to_array
+    values = np.array([True, False, True, False], dtype="bool")
+    mask = np.array([False, False, False, True], dtype="bool")
+    arr = BooleanArray(values, mask)
+    result = BooleanArray(*coerce_to_array(arr))
+    tm.assert_extension_array_equal(result, arr)
+    # no copy
+    assert result._data is arr._data
+    assert result._mask is arr._mask
+
+    result = BooleanArray(*coerce_to_array(arr), copy=True)
+    tm.assert_extension_array_equal(result, arr)
+    assert result._data is not arr._data
+    assert result._mask is not arr._mask
+
+    with pytest.raises(ValueError, match="cannot pass mask for BooleanArray input"):
+        coerce_to_array(arr, mask=mask)
+
+
+def test_coerce_to_numpy_array():
+    # with missing values -> object dtype
+    arr = pd.array([True, False, None], dtype="boolean")
+    result = np.array(arr)
+    expected = np.array([True, False, pd.NA], dtype="object")
+    tm.assert_numpy_array_equal(result, expected)
+
+    # also with no missing values -> object dtype
+    arr = pd.array([True, False, True], dtype="boolean")
+    result = np.array(arr)
+    expected = np.array([True, False, True], dtype="bool")
+    tm.assert_numpy_array_equal(result, expected)
+
+    # force bool dtype
+    result = np.array(arr, dtype="bool")
+    expected = np.array([True, False, True], dtype="bool")
+    tm.assert_numpy_array_equal(result, expected)
+    # with missing values will raise error
+    arr = pd.array([True, False, None], dtype="boolean")
+    msg = (
+        "cannot convert to 'bool'-dtype NumPy array with missing values. "
+        "Specify an appropriate 'na_value' for this dtype."
+    )
+    with pytest.raises(ValueError, match=msg):
+        np.array(arr, dtype="bool")
+
+
+def test_to_boolean_array_from_strings():
+    result = BooleanArray._from_sequence_of_strings(
+        np.array(["True", "False", "1", "1.0", "0", "0.0", np.nan], dtype=object),
+        dtype="boolean",
+    )
+    expected = BooleanArray(
+        np.array([True, False, True, True, False, False, False]),
+        np.array([False, False, False, False, False, False, True]),
+    )
+
+    tm.assert_extension_array_equal(result, expected)
+
+
+def test_to_boolean_array_from_strings_invalid_string():
+    with pytest.raises(ValueError, match="cannot be cast"):
+        BooleanArray._from_sequence_of_strings(["donkey"], dtype="boolean")
+
+
+@pytest.mark.parametrize("box", [True, False], ids=["series", "array"])
+def test_to_numpy(box):
+    con = pd.Series if box else pd.array
+    # default (with or without missing values) -> object dtype
+    arr = con([True, False, True], dtype="boolean")
+    result = arr.to_numpy()
+    expected = np.array([True, False, True], dtype="bool")
+    tm.assert_numpy_array_equal(result, expected)
+
+    arr = con([True, False, None], dtype="boolean")
+    result = arr.to_numpy()
+    expected = np.array([True, False, pd.NA], dtype="object")
+    tm.assert_numpy_array_equal(result, expected)
+
+    arr = con([True, False, None], dtype="boolean")
+    result = arr.to_numpy(dtype="str")
+    expected = np.array([True, False, pd.NA], dtype=f"{tm.ENDIAN}U5")
+    tm.assert_numpy_array_equal(result, expected)
+
+    # no missing values -> can convert to bool, otherwise raises
+    arr = con([True, False, True], dtype="boolean")
+    result = arr.to_numpy(dtype="bool")
+    expected = np.array([True, False, True], dtype="bool")
+    tm.assert_numpy_array_equal(result, expected)
+
+    arr = con([True, False, None], dtype="boolean")
+    with pytest.raises(ValueError, match="cannot convert to 'bool'-dtype"):
+        result = arr.to_numpy(dtype="bool")
+
+    # specify dtype and na_value
+    arr = con([True, False, None], dtype="boolean")
+    result = arr.to_numpy(dtype=object, na_value=None)
+    expected = np.array([True, False, None], dtype="object")
+    tm.assert_numpy_array_equal(result, expected)
+
+    result = arr.to_numpy(dtype=bool, na_value=False)
+    expected = np.array([True, False, False], dtype="bool")
+    tm.assert_numpy_array_equal(result, expected)
+
+    result = arr.to_numpy(dtype="int64", na_value=-99)
+    expected = np.array([1, 0, -99], dtype="int64")
+    tm.assert_numpy_array_equal(result, expected)
+
+    result = arr.to_numpy(dtype="float64", na_value=np.nan)
+    expected = np.array([1, 0, np.nan], dtype="float64")
+    tm.assert_numpy_array_equal(result, expected)
+
+    # converting to int or float without specifying na_value raises
+    with pytest.raises(ValueError, match="cannot convert to 'int64'-dtype"):
+        arr.to_numpy(dtype="int64")
+
+
+def test_to_numpy_copy():
+    # to_numpy can be zero-copy if no missing values
+    arr = pd.array([True, False, True], dtype="boolean")
+    result = arr.to_numpy(dtype=bool)
+    result[0] = False
+    tm.assert_extension_array_equal(
+        arr, pd.array([False, False, True], dtype="boolean")
+    )
+
+    arr = pd.array([True, False, True], dtype="boolean")
+    result = arr.to_numpy(dtype=bool, copy=True)
+    result[0] = False
+    tm.assert_extension_array_equal(arr, pd.array([True, False, True], dtype="boolean"))

venv/lib/python3.10/site-packages/pandas/tests/arrays/boolean/test_function.py

@@ -0,0 +1,126 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+
+
+@pytest.mark.parametrize(
+    "ufunc", [np.add, np.logical_or, np.logical_and, np.logical_xor]
+)
+def test_ufuncs_binary(ufunc):
+    # two BooleanArrays
+    a = pd.array([True, False, None], dtype="boolean")
+    result = ufunc(a, a)
+    expected = pd.array(ufunc(a._data, a._data), dtype="boolean")
+    expected[a._mask] = np.nan
+    tm.assert_extension_array_equal(result, expected)
+
+    s = pd.Series(a)
+    result = ufunc(s, a)
+    expected = pd.Series(ufunc(a._data, a._data), dtype="boolean")
+    expected[a._mask] = np.nan
+    tm.assert_series_equal(result, expected)
+
+    # Boolean with numpy array
+    arr = np.array([True, True, False])
+    result = ufunc(a, arr)
+    expected = pd.array(ufunc(a._data, arr), dtype="boolean")
+    expected[a._mask] = np.nan
+    tm.assert_extension_array_equal(result, expected)
+
+    result = ufunc(arr, a)
+    expected = pd.array(ufunc(arr, a._data), dtype="boolean")
+    expected[a._mask] = np.nan
+    tm.assert_extension_array_equal(result, expected)
+
+    # BooleanArray with scalar
+    result = ufunc(a, True)
+    expected = pd.array(ufunc(a._data, True), dtype="boolean")
+    expected[a._mask] = np.nan
+    tm.assert_extension_array_equal(result, expected)
+
+    result = ufunc(True, a)
+    expected = pd.array(ufunc(True, a._data), dtype="boolean")
+    expected[a._mask] = np.nan
+    tm.assert_extension_array_equal(result, expected)
+
+    # not handled types
+    msg = r"operand type\(s\) all returned NotImplemented from __array_ufunc__"
+    with pytest.raises(TypeError, match=msg):
+        ufunc(a, "test")
+
+
+@pytest.mark.parametrize("ufunc", [np.logical_not])
+def test_ufuncs_unary(ufunc):
+    a = pd.array([True, False, None], dtype="boolean")
+    result = ufunc(a)
+    expected = pd.array(ufunc(a._data), dtype="boolean")
+    expected[a._mask] = np.nan
+    tm.assert_extension_array_equal(result, expected)
+
+    ser = pd.Series(a)
+    result = ufunc(ser)
+    expected = pd.Series(ufunc(a._data), dtype="boolean")
+    expected[a._mask] = np.nan
+    tm.assert_series_equal(result, expected)
+
+
+def test_ufunc_numeric():
+    # np.sqrt on np.bool_ returns float16, which we upcast to Float32
+    #  bc we do not have Float16
+    arr = pd.array([True, False, None], dtype="boolean")
+
+    res = np.sqrt(arr)
+
+    expected = pd.array([1, 0, None], dtype="Float32")
+    tm.assert_extension_array_equal(res, expected)
+
+
+@pytest.mark.parametrize("values", [[True, False], [True, None]])
+def test_ufunc_reduce_raises(values):
+    arr = pd.array(values, dtype="boolean")
+
+    res = np.add.reduce(arr)
+    if arr[-1] is pd.NA:
+        expected = pd.NA
+    else:
+        expected = arr._data.sum()
+    tm.assert_almost_equal(res, expected)
+
+
+def test_value_counts_na():
+    arr = pd.array([True, False, pd.NA], dtype="boolean")
+    result = arr.value_counts(dropna=False)
+    expected = pd.Series([1, 1, 1], index=arr, dtype="Int64", name="count")
+    assert expected.index.dtype == arr.dtype
+    tm.assert_series_equal(result, expected)
+
+    result = arr.value_counts(dropna=True)
+    expected = pd.Series([1, 1], index=arr[:-1], dtype="Int64", name="count")
+    assert expected.index.dtype == arr.dtype
+    tm.assert_series_equal(result, expected)
+
+
+def test_value_counts_with_normalize():
+    ser = pd.Series([True, False, pd.NA], dtype="boolean")
+    result = ser.value_counts(normalize=True)
+    expected = pd.Series([1, 1], index=ser[:-1], dtype="Float64", name="proportion") / 2
+    assert expected.index.dtype == "boolean"
+    tm.assert_series_equal(result, expected)
+
+
+def test_diff():
+    a = pd.array(
+        [True, True, False, False, True, None, True, None, False], dtype="boolean"
+    )
+    result = pd.core.algorithms.diff(a, 1)
+    expected = pd.array(
+        [None, False, True, False, True, None, None, None, None], dtype="boolean"
+    )
+    tm.assert_extension_array_equal(result, expected)
+
+    ser = pd.Series(a)
+    result = ser.diff()
+    expected = pd.Series(expected)
+    tm.assert_series_equal(result, expected)

venv/lib/python3.10/site-packages/pandas/tests/arrays/boolean/test_indexing.py

@@ -0,0 +1,13 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+
+
+@pytest.mark.parametrize("na", [None, np.nan, pd.NA])
+def test_setitem_missing_values(na):
+    arr = pd.array([True, False, None], dtype="boolean")
+    expected = pd.array([True, None, None], dtype="boolean")
+    arr[1] = na
+    tm.assert_extension_array_equal(arr, expected)

venv/lib/python3.10/site-packages/pandas/tests/arrays/boolean/test_logical.py

@@ -0,0 +1,254 @@
+import operator
+
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+from pandas.arrays import BooleanArray
+from pandas.core.ops.mask_ops import (
+    kleene_and,
+    kleene_or,
+    kleene_xor,
+)
+from pandas.tests.extension.base import BaseOpsUtil
+
+
+class TestLogicalOps(BaseOpsUtil):
+    def test_numpy_scalars_ok(self, all_logical_operators):
+        a = pd.array([True, False, None], dtype="boolean")
+        op = getattr(a, all_logical_operators)
+
+        tm.assert_extension_array_equal(op(True), op(np.bool_(True)))
+        tm.assert_extension_array_equal(op(False), op(np.bool_(False)))
+
+    def get_op_from_name(self, op_name):
+        short_opname = op_name.strip("_")
+        short_opname = short_opname if "xor" in short_opname else short_opname + "_"
+        try:
+            op = getattr(operator, short_opname)
+        except AttributeError:
+            # Assume it is the reverse operator
+            rop = getattr(operator, short_opname[1:])
+            op = lambda x, y: rop(y, x)
+
+        return op
+
+    def test_empty_ok(self, all_logical_operators):
+        a = pd.array([], dtype="boolean")
+        op_name = all_logical_operators
+        result = getattr(a, op_name)(True)
+        tm.assert_extension_array_equal(a, result)
+
+        result = getattr(a, op_name)(False)
+        tm.assert_extension_array_equal(a, result)
+
+        result = getattr(a, op_name)(pd.NA)
+        tm.assert_extension_array_equal(a, result)
+
+    @pytest.mark.parametrize(
+        "other", ["a", pd.Timestamp(2017, 1, 1, 12), np.timedelta64(4)]
+    )
+    def test_eq_mismatched_type(self, other):
+        # GH-44499
+        arr = pd.array([True, False])
+        result = arr == other
+        expected = pd.array([False, False])
+        tm.assert_extension_array_equal(result, expected)
+
+        result = arr != other
+        expected = pd.array([True, True])
+        tm.assert_extension_array_equal(result, expected)
+
+    def test_logical_length_mismatch_raises(self, all_logical_operators):
+        op_name = all_logical_operators
+        a = pd.array([True, False, None], dtype="boolean")
+        msg = "Lengths must match"
+
+        with pytest.raises(ValueError, match=msg):
+            getattr(a, op_name)([True, False])
+
+        with pytest.raises(ValueError, match=msg):
+            getattr(a, op_name)(np.array([True, False]))
+
+        with pytest.raises(ValueError, match=msg):
+            getattr(a, op_name)(pd.array([True, False], dtype="boolean"))
+
+    def test_logical_nan_raises(self, all_logical_operators):
+        op_name = all_logical_operators
+        a = pd.array([True, False, None], dtype="boolean")
+        msg = "Got float instead"
+
+        with pytest.raises(TypeError, match=msg):
+            getattr(a, op_name)(np.nan)
+
+    @pytest.mark.parametrize("other", ["a", 1])
+    def test_non_bool_or_na_other_raises(self, other, all_logical_operators):
+        a = pd.array([True, False], dtype="boolean")
+        with pytest.raises(TypeError, match=str(type(other).__name__)):
+            getattr(a, all_logical_operators)(other)
+
+    def test_kleene_or(self):
+        # A clear test of behavior.
+        a = pd.array([True] * 3 + [False] * 3 + [None] * 3, dtype="boolean")
+        b = pd.array([True, False, None] * 3, dtype="boolean")
+        result = a | b
+        expected = pd.array(
+            [True, True, True, True, False, None, True, None, None], dtype="boolean"
+        )
+        tm.assert_extension_array_equal(result, expected)
+
+        result = b | a
+        tm.assert_extension_array_equal(result, expected)
+
+        # ensure we haven't mutated anything inplace
+        tm.assert_extension_array_equal(
+            a, pd.array([True] * 3 + [False] * 3 + [None] * 3, dtype="boolean")
+        )
+        tm.assert_extension_array_equal(
+            b, pd.array([True, False, None] * 3, dtype="boolean")
+        )
+
+    @pytest.mark.parametrize(
+        "other, expected",
+        [
+            (pd.NA, [True, None, None]),
+            (True, [True, True, True]),
+            (np.bool_(True), [True, True, True]),
+            (False, [True, False, None]),
+            (np.bool_(False), [True, False, None]),
+        ],
+    )
+    def test_kleene_or_scalar(self, other, expected):
+        # TODO: test True & False
+        a = pd.array([True, False, None], dtype="boolean")
+        result = a | other
+        expected = pd.array(expected, dtype="boolean")
+        tm.assert_extension_array_equal(result, expected)
+
+        result = other | a
+        tm.assert_extension_array_equal(result, expected)
+
+        # ensure we haven't mutated anything inplace
+        tm.assert_extension_array_equal(
+            a, pd.array([True, False, None], dtype="boolean")
+        )
+
+    def test_kleene_and(self):
+        # A clear test of behavior.
+        a = pd.array([True] * 3 + [False] * 3 + [None] * 3, dtype="boolean")
+        b = pd.array([True, False, None] * 3, dtype="boolean")
+        result = a & b
+        expected = pd.array(
+            [True, False, None, False, False, False, None, False, None], dtype="boolean"
+        )
+        tm.assert_extension_array_equal(result, expected)
+
+        result = b & a
+        tm.assert_extension_array_equal(result, expected)
+
+        # ensure we haven't mutated anything inplace
+        tm.assert_extension_array_equal(
+            a, pd.array([True] * 3 + [False] * 3 + [None] * 3, dtype="boolean")
+        )
+        tm.assert_extension_array_equal(
+            b, pd.array([True, False, None] * 3, dtype="boolean")
+        )
+
+    @pytest.mark.parametrize(
+        "other, expected",
+        [
+            (pd.NA, [None, False, None]),
+            (True, [True, False, None]),
+            (False, [False, False, False]),
+            (np.bool_(True), [True, False, None]),
+            (np.bool_(False), [False, False, False]),
+        ],
+    )
+    def test_kleene_and_scalar(self, other, expected):
+        a = pd.array([True, False, None], dtype="boolean")
+        result = a & other
+        expected = pd.array(expected, dtype="boolean")
+        tm.assert_extension_array_equal(result, expected)
+
+        result = other & a
+        tm.assert_extension_array_equal(result, expected)
+
+        # ensure we haven't mutated anything inplace
+        tm.assert_extension_array_equal(
+            a, pd.array([True, False, None], dtype="boolean")
+        )
+
+    def test_kleene_xor(self):
+        a = pd.array([True] * 3 + [False] * 3 + [None] * 3, dtype="boolean")
+        b = pd.array([True, False, None] * 3, dtype="boolean")
+        result = a ^ b
+        expected = pd.array(
+            [False, True, None, True, False, None, None, None, None], dtype="boolean"
+        )
+        tm.assert_extension_array_equal(result, expected)
+
+        result = b ^ a
+        tm.assert_extension_array_equal(result, expected)
+
+        # ensure we haven't mutated anything inplace
+        tm.assert_extension_array_equal(
+            a, pd.array([True] * 3 + [False] * 3 + [None] * 3, dtype="boolean")
+        )
+        tm.assert_extension_array_equal(
+            b, pd.array([True, False, None] * 3, dtype="boolean")
+        )
+
+    @pytest.mark.parametrize(
+        "other, expected",
+        [
+            (pd.NA, [None, None, None]),
+            (True, [False, True, None]),
+            (np.bool_(True), [False, True, None]),
+            (np.bool_(False), [True, False, None]),
+        ],
+    )
+    def test_kleene_xor_scalar(self, other, expected):
+        a = pd.array([True, False, None], dtype="boolean")
+        result = a ^ other
+        expected = pd.array(expected, dtype="boolean")
+        tm.assert_extension_array_equal(result, expected)
+
+        result = other ^ a
+        tm.assert_extension_array_equal(result, expected)
+
+        # ensure we haven't mutated anything inplace
+        tm.assert_extension_array_equal(
+            a, pd.array([True, False, None], dtype="boolean")
+        )
+
+    @pytest.mark.parametrize("other", [True, False, pd.NA, [True, False, None] * 3])
+    def test_no_masked_assumptions(self, other, all_logical_operators):
+        # The logical operations should not assume that masked values are False!
+        a = pd.arrays.BooleanArray(
+            np.array([True, True, True, False, False, False, True, False, True]),
+            np.array([False] * 6 + [True, True, True]),
+        )
+        b = pd.array([True] * 3 + [False] * 3 + [None] * 3, dtype="boolean")
+        if isinstance(other, list):
+            other = pd.array(other, dtype="boolean")
+
+        result = getattr(a, all_logical_operators)(other)
+        expected = getattr(b, all_logical_operators)(other)
+        tm.assert_extension_array_equal(result, expected)
+
+        if isinstance(other, BooleanArray):
+            other._data[other._mask] = True
+            a._data[a._mask] = False
+
+            result = getattr(a, all_logical_operators)(other)
+            expected = getattr(b, all_logical_operators)(other)
+            tm.assert_extension_array_equal(result, expected)
+
+
+@pytest.mark.parametrize("operation", [kleene_or, kleene_xor, kleene_and])
+def test_error_both_scalar(operation):
+    msg = r"Either `left` or `right` need to be a np\.ndarray."
+    with pytest.raises(TypeError, match=msg):
+        # masks need to be non-None, otherwise it ends up in an infinite recursion
+        operation(True, True, np.zeros(1), np.zeros(1))

venv/lib/python3.10/site-packages/pandas/tests/arrays/boolean/test_ops.py

@@ -0,0 +1,27 @@
+import pandas as pd
+import pandas._testing as tm
+
+
+class TestUnaryOps:
+    def test_invert(self):
+        a = pd.array([True, False, None], dtype="boolean")
+        expected = pd.array([False, True, None], dtype="boolean")
+        tm.assert_extension_array_equal(~a, expected)
+
+        expected = pd.Series(expected, index=["a", "b", "c"], name="name")
+        result = ~pd.Series(a, index=["a", "b", "c"], name="name")
+        tm.assert_series_equal(result, expected)
+
+        df = pd.DataFrame({"A": a, "B": [True, False, False]}, index=["a", "b", "c"])
+        result = ~df
+        expected = pd.DataFrame(
+            {"A": expected, "B": [False, True, True]}, index=["a", "b", "c"]
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_abs(self):
+        # matching numpy behavior, abs is the identity function
+        arr = pd.array([True, False, None], dtype="boolean")
+        result = abs(arr)
+
+        tm.assert_extension_array_equal(result, arr)

venv/lib/python3.10/site-packages/pandas/tests/arrays/boolean/test_reduction.py

@@ -0,0 +1,62 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+
+
+@pytest.fixture
+def data():
+    """Fixture returning boolean array, with valid and missing values."""
+    return pd.array(
+        [True, False] * 4 + [np.nan] + [True, False] * 44 + [np.nan] + [True, False],
+        dtype="boolean",
+    )
+
+
+@pytest.mark.parametrize(
+    "values, exp_any, exp_all, exp_any_noskip, exp_all_noskip",
+    [
+        ([True, pd.NA], True, True, True, pd.NA),
+        ([False, pd.NA], False, False, pd.NA, False),
+        ([pd.NA], False, True, pd.NA, pd.NA),
+        ([], False, True, False, True),
+        # GH-33253: all True / all False values buggy with skipna=False
+        ([True, True], True, True, True, True),
+        ([False, False], False, False, False, False),
+    ],
+)
+def test_any_all(values, exp_any, exp_all, exp_any_noskip, exp_all_noskip):
+    # the methods return numpy scalars
+    exp_any = pd.NA if exp_any is pd.NA else np.bool_(exp_any)
+    exp_all = pd.NA if exp_all is pd.NA else np.bool_(exp_all)
+    exp_any_noskip = pd.NA if exp_any_noskip is pd.NA else np.bool_(exp_any_noskip)
+    exp_all_noskip = pd.NA if exp_all_noskip is pd.NA else np.bool_(exp_all_noskip)
+
+    for con in [pd.array, pd.Series]:
+        a = con(values, dtype="boolean")
+        assert a.any() is exp_any
+        assert a.all() is exp_all
+        assert a.any(skipna=False) is exp_any_noskip
+        assert a.all(skipna=False) is exp_all_noskip
+
+        assert np.any(a.any()) is exp_any
+        assert np.all(a.all()) is exp_all
+
+
+@pytest.mark.parametrize("dropna", [True, False])
+def test_reductions_return_types(dropna, data, all_numeric_reductions):
+    op = all_numeric_reductions
+    s = pd.Series(data)
+    if dropna:
+        s = s.dropna()
+
+    if op in ("sum", "prod"):
+        assert isinstance(getattr(s, op)(), np.int_)
+    elif op == "count":
+        # Oddly on the 32 bit build (but not Windows), this is intc (!= intp)
+        assert isinstance(getattr(s, op)(), np.integer)
+    elif op in ("min", "max"):
+        assert isinstance(getattr(s, op)(), np.bool_)
+    else:
+        # "mean", "std", "var", "median", "kurt", "skew"
+        assert isinstance(getattr(s, op)(), np.float64)

venv/lib/python3.10/site-packages/pandas/tests/arrays/boolean/test_repr.py

@@ -0,0 +1,13 @@
+import pandas as pd
+
+
+def test_repr():
+    df = pd.DataFrame({"A": pd.array([True, False, None], dtype="boolean")})
+    expected = "       A\n0   True\n1  False\n2   <NA>"
+    assert repr(df) == expected
+
+    expected = "0     True\n1    False\n2     <NA>\nName: A, dtype: boolean"
+    assert repr(df.A) == expected
+
+    expected = "<BooleanArray>\n[True, False, <NA>]\nLength: 3, dtype: boolean"
+    assert repr(df.A.array) == expected

venv/lib/python3.10/site-packages/pandas/tests/arrays/datetimes/test_constructors.py

@@ -0,0 +1,284 @@
+import numpy as np
+import pytest
+
+from pandas._libs import iNaT
+
+from pandas.core.dtypes.dtypes import DatetimeTZDtype
+
+import pandas as pd
+import pandas._testing as tm
+from pandas.core.arrays import DatetimeArray
+
+
+class TestDatetimeArrayConstructor:
+    def test_from_sequence_invalid_type(self):
+        mi = pd.MultiIndex.from_product([np.arange(5), np.arange(5)])
+        with pytest.raises(TypeError, match="Cannot create a DatetimeArray"):
+            DatetimeArray._from_sequence(mi, dtype="M8[ns]")
+
+    def test_only_1dim_accepted(self):
+        arr = np.array([0, 1, 2, 3], dtype="M8[h]").astype("M8[ns]")
+
+        depr_msg = "DatetimeArray.__init__ is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=depr_msg):
+            with pytest.raises(ValueError, match="Only 1-dimensional"):
+                # 3-dim, we allow 2D to sneak in for ops purposes GH#29853
+                DatetimeArray(arr.reshape(2, 2, 1))
+
+        with tm.assert_produces_warning(FutureWarning, match=depr_msg):
+            with pytest.raises(ValueError, match="Only 1-dimensional"):
+                # 0-dim
+                DatetimeArray(arr[[0]].squeeze())
+
+    def test_freq_validation(self):
+        # GH#24623 check that invalid instances cannot be created with the
+        #  public constructor
+        arr = np.arange(5, dtype=np.int64) * 3600 * 10**9
+
+        msg = (
+            "Inferred frequency h from passed values does not "
+            "conform to passed frequency W-SUN"
+        )
+        depr_msg = "DatetimeArray.__init__ is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=depr_msg):
+            with pytest.raises(ValueError, match=msg):
+                DatetimeArray(arr, freq="W")
+
+    @pytest.mark.parametrize(
+        "meth",
+        [
+            DatetimeArray._from_sequence,
+            pd.to_datetime,
+            pd.DatetimeIndex,
+        ],
+    )
+    def test_mixing_naive_tzaware_raises(self, meth):
+        # GH#24569
+        arr = np.array([pd.Timestamp("2000"), pd.Timestamp("2000", tz="CET")])
+
+        msg = (
+            "Cannot mix tz-aware with tz-naive values|"
+            "Tz-aware datetime.datetime cannot be converted "
+            "to datetime64 unless utc=True"
+        )
+
+        for obj in [arr, arr[::-1]]:
+            # check that we raise regardless of whether naive is found
+            #  before aware or vice-versa
+            with pytest.raises(ValueError, match=msg):
+                meth(obj)
+
+    def test_from_pandas_array(self):
+        arr = pd.array(np.arange(5, dtype=np.int64)) * 3600 * 10**9
+
+        result = DatetimeArray._from_sequence(arr, dtype="M8[ns]")._with_freq("infer")
+
+        expected = pd.date_range("1970-01-01", periods=5, freq="h")._data
+        tm.assert_datetime_array_equal(result, expected)
+
+    def test_mismatched_timezone_raises(self):
+        depr_msg = "DatetimeArray.__init__ is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=depr_msg):
+            arr = DatetimeArray(
+                np.array(["2000-01-01T06:00:00"], dtype="M8[ns]"),
+                dtype=DatetimeTZDtype(tz="US/Central"),
+            )
+        dtype = DatetimeTZDtype(tz="US/Eastern")
+        msg = r"dtype=datetime64\[ns.*\] does not match data dtype datetime64\[ns.*\]"
+        with tm.assert_produces_warning(FutureWarning, match=depr_msg):
+            with pytest.raises(TypeError, match=msg):
+                DatetimeArray(arr, dtype=dtype)
+
+        # also with mismatched tzawareness
+        with tm.assert_produces_warning(FutureWarning, match=depr_msg):
+            with pytest.raises(TypeError, match=msg):
+                DatetimeArray(arr, dtype=np.dtype("M8[ns]"))
+        with tm.assert_produces_warning(FutureWarning, match=depr_msg):
+            with pytest.raises(TypeError, match=msg):
+                DatetimeArray(arr.tz_localize(None), dtype=arr.dtype)
+
+    def test_non_array_raises(self):
+        depr_msg = "DatetimeArray.__init__ is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=depr_msg):
+            with pytest.raises(ValueError, match="list"):
+                DatetimeArray([1, 2, 3])
+
+    def test_bool_dtype_raises(self):
+        arr = np.array([1, 2, 3], dtype="bool")
+
+        depr_msg = "DatetimeArray.__init__ is deprecated"
+        msg = "Unexpected value for 'dtype': 'bool'. Must be"
+        with tm.assert_produces_warning(FutureWarning, match=depr_msg):
+            with pytest.raises(ValueError, match=msg):
+                DatetimeArray(arr)
+
+        msg = r"dtype bool cannot be converted to datetime64\[ns\]"
+        with pytest.raises(TypeError, match=msg):
+            DatetimeArray._from_sequence(arr, dtype="M8[ns]")
+
+        with pytest.raises(TypeError, match=msg):
+            pd.DatetimeIndex(arr)
+
+        with pytest.raises(TypeError, match=msg):
+            pd.to_datetime(arr)
+
+    def test_incorrect_dtype_raises(self):
+        depr_msg = "DatetimeArray.__init__ is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=depr_msg):
+            with pytest.raises(ValueError, match="Unexpected value for 'dtype'."):
+                DatetimeArray(np.array([1, 2, 3], dtype="i8"), dtype="category")
+
+        with tm.assert_produces_warning(FutureWarning, match=depr_msg):
+            with pytest.raises(ValueError, match="Unexpected value for 'dtype'."):
+                DatetimeArray(np.array([1, 2, 3], dtype="i8"), dtype="m8[s]")
+
+        with tm.assert_produces_warning(FutureWarning, match=depr_msg):
+            with pytest.raises(ValueError, match="Unexpected value for 'dtype'."):
+                DatetimeArray(np.array([1, 2, 3], dtype="i8"), dtype="M8[D]")
+
+    def test_mismatched_values_dtype_units(self):
+        arr = np.array([1, 2, 3], dtype="M8[s]")
+        dtype = np.dtype("M8[ns]")
+        msg = "Values resolution does not match dtype."
+        depr_msg = "DatetimeArray.__init__ is deprecated"
+
+        with tm.assert_produces_warning(FutureWarning, match=depr_msg):
+            with pytest.raises(ValueError, match=msg):
+                DatetimeArray(arr, dtype=dtype)
+
+        dtype2 = DatetimeTZDtype(tz="UTC", unit="ns")
+        with tm.assert_produces_warning(FutureWarning, match=depr_msg):
+            with pytest.raises(ValueError, match=msg):
+                DatetimeArray(arr, dtype=dtype2)
+
+    def test_freq_infer_raises(self):
+        depr_msg = "DatetimeArray.__init__ is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=depr_msg):
+            with pytest.raises(ValueError, match="Frequency inference"):
+                DatetimeArray(np.array([1, 2, 3], dtype="i8"), freq="infer")
+
+    def test_copy(self):
+        data = np.array([1, 2, 3], dtype="M8[ns]")
+        arr = DatetimeArray._from_sequence(data, copy=False)
+        assert arr._ndarray is data
+
+        arr = DatetimeArray._from_sequence(data, copy=True)
+        assert arr._ndarray is not data
+
+    @pytest.mark.parametrize("unit", ["s", "ms", "us", "ns"])
+    def test_numpy_datetime_unit(self, unit):
+        data = np.array([1, 2, 3], dtype=f"M8[{unit}]")
+        arr = DatetimeArray._from_sequence(data)
+        assert arr.unit == unit
+        assert arr[0].unit == unit
+
+
+class TestSequenceToDT64NS:
+    def test_tz_dtype_mismatch_raises(self):
+        arr = DatetimeArray._from_sequence(
+            ["2000"], dtype=DatetimeTZDtype(tz="US/Central")
+        )
+        with pytest.raises(TypeError, match="data is already tz-aware"):
+            DatetimeArray._from_sequence(arr, dtype=DatetimeTZDtype(tz="UTC"))
+
+    def test_tz_dtype_matches(self):
+        dtype = DatetimeTZDtype(tz="US/Central")
+        arr = DatetimeArray._from_sequence(["2000"], dtype=dtype)
+        result = DatetimeArray._from_sequence(arr, dtype=dtype)
+        tm.assert_equal(arr, result)
+
+    @pytest.mark.parametrize("order", ["F", "C"])
+    def test_2d(self, order):
+        dti = pd.date_range("2016-01-01", periods=6, tz="US/Pacific")
+        arr = np.array(dti, dtype=object).reshape(3, 2)
+        if order == "F":
+            arr = arr.T
+
+        res = DatetimeArray._from_sequence(arr, dtype=dti.dtype)
+        expected = DatetimeArray._from_sequence(arr.ravel(), dtype=dti.dtype).reshape(
+            arr.shape
+        )
+        tm.assert_datetime_array_equal(res, expected)
+
+
+# ----------------------------------------------------------------------------
+# Arrow interaction
+
+
+EXTREME_VALUES = [0, 123456789, None, iNaT, 2**63 - 1, -(2**63) + 1]
+FINE_TO_COARSE_SAFE = [123_000_000_000, None, -123_000_000_000]
+COARSE_TO_FINE_SAFE = [123, None, -123]
+
+
+@pytest.mark.parametrize(
+    ("pa_unit", "pd_unit", "pa_tz", "pd_tz", "data"),
+    [
+        ("s", "s", "UTC", "UTC", EXTREME_VALUES),
+        ("ms", "ms", "UTC", "Europe/Berlin", EXTREME_VALUES),
+        ("us", "us", "US/Eastern", "UTC", EXTREME_VALUES),
+        ("ns", "ns", "US/Central", "Asia/Kolkata", EXTREME_VALUES),
+        ("ns", "s", "UTC", "UTC", FINE_TO_COARSE_SAFE),
+        ("us", "ms", "UTC", "Europe/Berlin", FINE_TO_COARSE_SAFE),
+        ("ms", "us", "US/Eastern", "UTC", COARSE_TO_FINE_SAFE),
+        ("s", "ns", "US/Central", "Asia/Kolkata", COARSE_TO_FINE_SAFE),
+    ],
+)
+def test_from_arrow_with_different_units_and_timezones_with(
+    pa_unit, pd_unit, pa_tz, pd_tz, data
+):
+    pa = pytest.importorskip("pyarrow")
+
+    pa_type = pa.timestamp(pa_unit, tz=pa_tz)
+    arr = pa.array(data, type=pa_type)
+    dtype = DatetimeTZDtype(unit=pd_unit, tz=pd_tz)
+
+    result = dtype.__from_arrow__(arr)
+    expected = DatetimeArray._from_sequence(data, dtype=f"M8[{pa_unit}, UTC]").astype(
+        dtype, copy=False
+    )
+    tm.assert_extension_array_equal(result, expected)
+
+    result = dtype.__from_arrow__(pa.chunked_array([arr]))
+    tm.assert_extension_array_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    ("unit", "tz"),
+    [
+        ("s", "UTC"),
+        ("ms", "Europe/Berlin"),
+        ("us", "US/Eastern"),
+        ("ns", "Asia/Kolkata"),
+        ("ns", "UTC"),
+    ],
+)
+def test_from_arrow_from_empty(unit, tz):
+    pa = pytest.importorskip("pyarrow")
+
+    data = []
+    arr = pa.array(data)
+    dtype = DatetimeTZDtype(unit=unit, tz=tz)
+
+    result = dtype.__from_arrow__(arr)
+    expected = DatetimeArray._from_sequence(np.array(data, dtype=f"datetime64[{unit}]"))
+    expected = expected.tz_localize(tz=tz)
+    tm.assert_extension_array_equal(result, expected)
+
+    result = dtype.__from_arrow__(pa.chunked_array([arr]))
+    tm.assert_extension_array_equal(result, expected)
+
+
+def test_from_arrow_from_integers():
+    pa = pytest.importorskip("pyarrow")
+
+    data = [0, 123456789, None, 2**63 - 1, iNaT, -123456789]
+    arr = pa.array(data)
+    dtype = DatetimeTZDtype(unit="ns", tz="UTC")
+
+    result = dtype.__from_arrow__(arr)
+    expected = DatetimeArray._from_sequence(np.array(data, dtype="datetime64[ns]"))
+    expected = expected.tz_localize("UTC")
+    tm.assert_extension_array_equal(result, expected)
+
+    result = dtype.__from_arrow__(pa.chunked_array([arr]))
+    tm.assert_extension_array_equal(result, expected)

venv/lib/python3.10/site-packages/pandas/tests/arrays/datetimes/test_cumulative.py

@@ -0,0 +1,44 @@
+import pytest
+
+import pandas._testing as tm
+from pandas.core.arrays import DatetimeArray
+
+
+class TestAccumulator:
+    def test_accumulators_freq(self):
+        # GH#50297
+        arr = DatetimeArray._from_sequence(
+            [
+                "2000-01-01",
+                "2000-01-02",
+                "2000-01-03",
+            ],
+            dtype="M8[ns]",
+        )._with_freq("infer")
+        result = arr._accumulate("cummin")
+        expected = DatetimeArray._from_sequence(["2000-01-01"] * 3, dtype="M8[ns]")
+        tm.assert_datetime_array_equal(result, expected)
+
+        result = arr._accumulate("cummax")
+        expected = DatetimeArray._from_sequence(
+            [
+                "2000-01-01",
+                "2000-01-02",
+                "2000-01-03",
+            ],
+            dtype="M8[ns]",
+        )
+        tm.assert_datetime_array_equal(result, expected)
+
+    @pytest.mark.parametrize("func", ["cumsum", "cumprod"])
+    def test_accumulators_disallowed(self, func):
+        # GH#50297
+        arr = DatetimeArray._from_sequence(
+            [
+                "2000-01-01",
+                "2000-01-02",
+            ],
+            dtype="M8[ns]",
+        )._with_freq("infer")
+        with pytest.raises(TypeError, match=f"Accumulation {func}"):
+            arr._accumulate(func)

venv/lib/python3.10/site-packages/pandas/tests/arrays/datetimes/test_reductions.py

@@ -0,0 +1,183 @@
+import numpy as np
+import pytest
+
+from pandas.core.dtypes.dtypes import DatetimeTZDtype
+
+import pandas as pd
+from pandas import NaT
+import pandas._testing as tm
+from pandas.core.arrays import DatetimeArray
+
+
+class TestReductions:
+    @pytest.fixture(params=["s", "ms", "us", "ns"])
+    def unit(self, request):
+        return request.param
+
+    @pytest.fixture
+    def arr1d(self, tz_naive_fixture):
+        """Fixture returning DatetimeArray with parametrized timezones"""
+        tz = tz_naive_fixture
+        dtype = DatetimeTZDtype(tz=tz) if tz is not None else np.dtype("M8[ns]")
+        arr = DatetimeArray._from_sequence(
+            [
+                "2000-01-03",
+                "2000-01-03",
+                "NaT",
+                "2000-01-02",
+                "2000-01-05",
+                "2000-01-04",
+            ],
+            dtype=dtype,
+        )
+        return arr
+
+    def test_min_max(self, arr1d, unit):
+        arr = arr1d
+        arr = arr.as_unit(unit)
+        tz = arr.tz
+
+        result = arr.min()
+        expected = pd.Timestamp("2000-01-02", tz=tz).as_unit(unit)
+        assert result == expected
+        assert result.unit == expected.unit
+
+        result = arr.max()
+        expected = pd.Timestamp("2000-01-05", tz=tz).as_unit(unit)
+        assert result == expected
+        assert result.unit == expected.unit
+
+        result = arr.min(skipna=False)
+        assert result is NaT
+
+        result = arr.max(skipna=False)
+        assert result is NaT
+
+    @pytest.mark.parametrize("tz", [None, "US/Central"])
+    @pytest.mark.parametrize("skipna", [True, False])
+    def test_min_max_empty(self, skipna, tz):
+        dtype = DatetimeTZDtype(tz=tz) if tz is not None else np.dtype("M8[ns]")
+        arr = DatetimeArray._from_sequence([], dtype=dtype)
+        result = arr.min(skipna=skipna)
+        assert result is NaT
+
+        result = arr.max(skipna=skipna)
+        assert result is NaT
+
+    @pytest.mark.parametrize("tz", [None, "US/Central"])
+    @pytest.mark.parametrize("skipna", [True, False])
+    def test_median_empty(self, skipna, tz):
+        dtype = DatetimeTZDtype(tz=tz) if tz is not None else np.dtype("M8[ns]")
+        arr = DatetimeArray._from_sequence([], dtype=dtype)
+        result = arr.median(skipna=skipna)
+        assert result is NaT
+
+        arr = arr.reshape(0, 3)
+        result = arr.median(axis=0, skipna=skipna)
+        expected = type(arr)._from_sequence([NaT, NaT, NaT], dtype=arr.dtype)
+        tm.assert_equal(result, expected)
+
+        result = arr.median(axis=1, skipna=skipna)
+        expected = type(arr)._from_sequence([], dtype=arr.dtype)
+        tm.assert_equal(result, expected)
+
+    def test_median(self, arr1d):
+        arr = arr1d
+
+        result = arr.median()
+        assert result == arr[0]
+        result = arr.median(skipna=False)
+        assert result is NaT
+
+        result = arr.dropna().median(skipna=False)
+        assert result == arr[0]
+
+        result = arr.median(axis=0)
+        assert result == arr[0]
+
+    def test_median_axis(self, arr1d):
+        arr = arr1d
+        assert arr.median(axis=0) == arr.median()
+        assert arr.median(axis=0, skipna=False) is NaT
+
+        msg = r"abs\(axis\) must be less than ndim"
+        with pytest.raises(ValueError, match=msg):
+            arr.median(axis=1)
+
+    @pytest.mark.filterwarnings("ignore:All-NaN slice encountered:RuntimeWarning")
+    def test_median_2d(self, arr1d):
+        arr = arr1d.reshape(1, -1)
+
+        # axis = None
+        assert arr.median() == arr1d.median()
+        assert arr.median(skipna=False) is NaT
+
+        # axis = 0
+        result = arr.median(axis=0)
+        expected = arr1d
+        tm.assert_equal(result, expected)
+
+        # Since column 3 is all-NaT, we get NaT there with or without skipna
+        result = arr.median(axis=0, skipna=False)
+        expected = arr1d
+        tm.assert_equal(result, expected)
+
+        # axis = 1
+        result = arr.median(axis=1)
+        expected = type(arr)._from_sequence([arr1d.median()], dtype=arr.dtype)
+        tm.assert_equal(result, expected)
+
+        result = arr.median(axis=1, skipna=False)
+        expected = type(arr)._from_sequence([NaT], dtype=arr.dtype)
+        tm.assert_equal(result, expected)
+
+    def test_mean(self, arr1d):
+        arr = arr1d
+
+        # manually verified result
+        expected = arr[0] + 0.4 * pd.Timedelta(days=1)
+
+        result = arr.mean()
+        assert result == expected
+        result = arr.mean(skipna=False)
+        assert result is NaT
+
+        result = arr.dropna().mean(skipna=False)
+        assert result == expected
+
+        result = arr.mean(axis=0)
+        assert result == expected
+
+    def test_mean_2d(self):
+        dti = pd.date_range("2016-01-01", periods=6, tz="US/Pacific")
+        dta = dti._data.reshape(3, 2)
+
+        result = dta.mean(axis=0)
+        expected = dta[1]
+        tm.assert_datetime_array_equal(result, expected)
+
+        result = dta.mean(axis=1)
+        expected = dta[:, 0] + pd.Timedelta(hours=12)
+        tm.assert_datetime_array_equal(result, expected)
+
+        result = dta.mean(axis=None)
+        expected = dti.mean()
+        assert result == expected
+
+    @pytest.mark.parametrize("skipna", [True, False])
+    def test_mean_empty(self, arr1d, skipna):
+        arr = arr1d[:0]
+
+        assert arr.mean(skipna=skipna) is NaT
+
+        arr2d = arr.reshape(0, 3)
+        result = arr2d.mean(axis=0, skipna=skipna)
+        expected = DatetimeArray._from_sequence([NaT, NaT, NaT], dtype=arr.dtype)
+        tm.assert_datetime_array_equal(result, expected)
+
+        result = arr2d.mean(axis=1, skipna=skipna)
+        expected = arr  # i.e. 1D, empty
+        tm.assert_datetime_array_equal(result, expected)
+
+        result = arr2d.mean(axis=None, skipna=skipna)
+        assert result is NaT

venv/lib/python3.10/site-packages/pandas/tests/arrays/masked/test_arithmetic.py

@@ -0,0 +1,248 @@
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+
+# integer dtypes
+arrays = [pd.array([1, 2, 3, None], dtype=dtype) for dtype in tm.ALL_INT_EA_DTYPES]
+scalars: list[Any] = [2] * len(arrays)
+# floating dtypes
+arrays += [pd.array([0.1, 0.2, 0.3, None], dtype=dtype) for dtype in tm.FLOAT_EA_DTYPES]
+scalars += [0.2, 0.2]
+# boolean
+arrays += [pd.array([True, False, True, None], dtype="boolean")]
+scalars += [False]
+
+
+@pytest.fixture(params=zip(arrays, scalars), ids=[a.dtype.name for a in arrays])
+def data(request):
+    """Fixture returning parametrized (array, scalar) tuple.
+
+    Used to test equivalence of scalars, numpy arrays with array ops, and the
+    equivalence of DataFrame and Series ops.
+    """
+    return request.param
+
+
+def check_skip(data, op_name):
+    if isinstance(data.dtype, pd.BooleanDtype) and "sub" in op_name:
+        pytest.skip("subtract not implemented for boolean")
+
+
+def is_bool_not_implemented(data, op_name):
+    # match non-masked behavior
+    return data.dtype.kind == "b" and op_name.strip("_").lstrip("r") in [
+        "pow",
+        "truediv",
+        "floordiv",
+    ]
+
+
+# Test equivalence of scalars, numpy arrays with array ops
+# -----------------------------------------------------------------------------
+
+
+def test_array_scalar_like_equivalence(data, all_arithmetic_operators):
+    data, scalar = data
+    op = tm.get_op_from_name(all_arithmetic_operators)
+    check_skip(data, all_arithmetic_operators)
+
+    scalar_array = pd.array([scalar] * len(data), dtype=data.dtype)
+
+    # TODO also add len-1 array (np.array([scalar], dtype=data.dtype.numpy_dtype))
+    for scalar in [scalar, data.dtype.type(scalar)]:
+        if is_bool_not_implemented(data, all_arithmetic_operators):
+            msg = "operator '.*' not implemented for bool dtypes"
+            with pytest.raises(NotImplementedError, match=msg):
+                op(data, scalar)
+            with pytest.raises(NotImplementedError, match=msg):
+                op(data, scalar_array)
+        else:
+            result = op(data, scalar)
+            expected = op(data, scalar_array)
+            tm.assert_extension_array_equal(result, expected)
+
+
+def test_array_NA(data, all_arithmetic_operators):
+    data, _ = data
+    op = tm.get_op_from_name(all_arithmetic_operators)
+    check_skip(data, all_arithmetic_operators)
+
+    scalar = pd.NA
+    scalar_array = pd.array([pd.NA] * len(data), dtype=data.dtype)
+
+    mask = data._mask.copy()
+
+    if is_bool_not_implemented(data, all_arithmetic_operators):
+        msg = "operator '.*' not implemented for bool dtypes"
+        with pytest.raises(NotImplementedError, match=msg):
+            op(data, scalar)
+        # GH#45421 check op doesn't alter data._mask inplace
+        tm.assert_numpy_array_equal(mask, data._mask)
+        return
+
+    result = op(data, scalar)
+    # GH#45421 check op doesn't alter data._mask inplace
+    tm.assert_numpy_array_equal(mask, data._mask)
+
+    expected = op(data, scalar_array)
+    tm.assert_numpy_array_equal(mask, data._mask)
+
+    tm.assert_extension_array_equal(result, expected)
+
+
+def test_numpy_array_equivalence(data, all_arithmetic_operators):
+    data, scalar = data
+    op = tm.get_op_from_name(all_arithmetic_operators)
+    check_skip(data, all_arithmetic_operators)
+
+    numpy_array = np.array([scalar] * len(data), dtype=data.dtype.numpy_dtype)
+    pd_array = pd.array(numpy_array, dtype=data.dtype)
+
+    if is_bool_not_implemented(data, all_arithmetic_operators):
+        msg = "operator '.*' not implemented for bool dtypes"
+        with pytest.raises(NotImplementedError, match=msg):
+            op(data, numpy_array)
+        with pytest.raises(NotImplementedError, match=msg):
+            op(data, pd_array)
+        return
+
+    result = op(data, numpy_array)
+    expected = op(data, pd_array)
+    tm.assert_extension_array_equal(result, expected)
+
+
+# Test equivalence with Series and DataFrame ops
+# -----------------------------------------------------------------------------
+
+
+def test_frame(data, all_arithmetic_operators):
+    data, scalar = data
+    op = tm.get_op_from_name(all_arithmetic_operators)
+    check_skip(data, all_arithmetic_operators)
+
+    # DataFrame with scalar
+    df = pd.DataFrame({"A": data})
+
+    if is_bool_not_implemented(data, all_arithmetic_operators):
+        msg = "operator '.*' not implemented for bool dtypes"
+        with pytest.raises(NotImplementedError, match=msg):
+            op(df, scalar)
+        with pytest.raises(NotImplementedError, match=msg):
+            op(data, scalar)
+        return
+
+    result = op(df, scalar)
+    expected = pd.DataFrame({"A": op(data, scalar)})
+    tm.assert_frame_equal(result, expected)
+
+
+def test_series(data, all_arithmetic_operators):
+    data, scalar = data
+    op = tm.get_op_from_name(all_arithmetic_operators)
+    check_skip(data, all_arithmetic_operators)
+
+    ser = pd.Series(data)
+
+    others = [
+        scalar,
+        np.array([scalar] * len(data), dtype=data.dtype.numpy_dtype),
+        pd.array([scalar] * len(data), dtype=data.dtype),
+        pd.Series([scalar] * len(data), dtype=data.dtype),
+    ]
+
+    for other in others:
+        if is_bool_not_implemented(data, all_arithmetic_operators):
+            msg = "operator '.*' not implemented for bool dtypes"
+            with pytest.raises(NotImplementedError, match=msg):
+                op(ser, other)
+
+        else:
+            result = op(ser, other)
+            expected = pd.Series(op(data, other))
+            tm.assert_series_equal(result, expected)
+
+
+# Test generic characteristics / errors
+# -----------------------------------------------------------------------------
+
+
+def test_error_invalid_object(data, all_arithmetic_operators):
+    data, _ = data
+
+    op = all_arithmetic_operators
+    opa = getattr(data, op)
+
+    # 2d -> return NotImplemented
+    result = opa(pd.DataFrame({"A": data}))
+    assert result is NotImplemented
+
+    msg = r"can only perform ops with 1-d structures"
+    with pytest.raises(NotImplementedError, match=msg):
+        opa(np.arange(len(data)).reshape(-1, len(data)))
+
+
+def test_error_len_mismatch(data, all_arithmetic_operators):
+    # operating with a list-like with non-matching length raises
+    data, scalar = data
+    op = tm.get_op_from_name(all_arithmetic_operators)
+
+    other = [scalar] * (len(data) - 1)
+
+    err = ValueError
+    msg = "|".join(
+        [
+            r"operands could not be broadcast together with shapes \(3,\) \(4,\)",
+            r"operands could not be broadcast together with shapes \(4,\) \(3,\)",
+        ]
+    )
+    if data.dtype.kind == "b" and all_arithmetic_operators.strip("_") in [
+        "sub",
+        "rsub",
+    ]:
+        err = TypeError
+        msg = (
+            r"numpy boolean subtract, the `\-` operator, is not supported, use "
+            r"the bitwise_xor, the `\^` operator, or the logical_xor function instead"
+        )
+    elif is_bool_not_implemented(data, all_arithmetic_operators):
+        msg = "operator '.*' not implemented for bool dtypes"
+        err = NotImplementedError
+
+    for other in [other, np.array(other)]:
+        with pytest.raises(err, match=msg):
+            op(data, other)
+
+        s = pd.Series(data)
+        with pytest.raises(err, match=msg):
+            op(s, other)
+
+
+@pytest.mark.parametrize("op", ["__neg__", "__abs__", "__invert__"])
+def test_unary_op_does_not_propagate_mask(data, op):
+    # https://github.com/pandas-dev/pandas/issues/39943
+    data, _ = data
+    ser = pd.Series(data)
+
+    if op == "__invert__" and data.dtype.kind == "f":
+        # we follow numpy in raising
+        msg = "ufunc 'invert' not supported for the input types"
+        with pytest.raises(TypeError, match=msg):
+            getattr(ser, op)()
+        with pytest.raises(TypeError, match=msg):
+            getattr(data, op)()
+        with pytest.raises(TypeError, match=msg):
+            # Check that this is still the numpy behavior
+            getattr(data._data, op)()
+
+        return
+
+    result = getattr(ser, op)()
+    expected = result.copy(deep=True)
+    ser[0] = None
+    tm.assert_series_equal(result, expected)

venv/lib/python3.10/site-packages/pandas/tests/arrays/masked/test_arrow_compat.py

@@ -0,0 +1,209 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+
+pytestmark = pytest.mark.filterwarnings(
+    "ignore:Passing a BlockManager to DataFrame:DeprecationWarning"
+)
+
+pa = pytest.importorskip("pyarrow")
+
+from pandas.core.arrays.arrow._arrow_utils import pyarrow_array_to_numpy_and_mask
+
+arrays = [pd.array([1, 2, 3, None], dtype=dtype) for dtype in tm.ALL_INT_EA_DTYPES]
+arrays += [pd.array([0.1, 0.2, 0.3, None], dtype=dtype) for dtype in tm.FLOAT_EA_DTYPES]
+arrays += [pd.array([True, False, True, None], dtype="boolean")]
+
+
+@pytest.fixture(params=arrays, ids=[a.dtype.name for a in arrays])
+def data(request):
+    """
+    Fixture returning parametrized array from given dtype, including integer,
+    float and boolean
+    """
+    return request.param
+
+
+def test_arrow_array(data):
+    arr = pa.array(data)
+    expected = pa.array(
+        data.to_numpy(object, na_value=None),
+        type=pa.from_numpy_dtype(data.dtype.numpy_dtype),
+    )
+    assert arr.equals(expected)
+
+
+def test_arrow_roundtrip(data):
+    df = pd.DataFrame({"a": data})
+    table = pa.table(df)
+    assert table.field("a").type == str(data.dtype.numpy_dtype)
+
+    result = table.to_pandas()
+    assert result["a"].dtype == data.dtype
+    tm.assert_frame_equal(result, df)
+
+
+def test_dataframe_from_arrow_types_mapper():
+    def types_mapper(arrow_type):
+        if pa.types.is_boolean(arrow_type):
+            return pd.BooleanDtype()
+        elif pa.types.is_integer(arrow_type):
+            return pd.Int64Dtype()
+
+    bools_array = pa.array([True, None, False], type=pa.bool_())
+    ints_array = pa.array([1, None, 2], type=pa.int64())
+    small_ints_array = pa.array([-1, 0, 7], type=pa.int8())
+    record_batch = pa.RecordBatch.from_arrays(
+        [bools_array, ints_array, small_ints_array], ["bools", "ints", "small_ints"]
+    )
+    result = record_batch.to_pandas(types_mapper=types_mapper)
+    bools = pd.Series([True, None, False], dtype="boolean")
+    ints = pd.Series([1, None, 2], dtype="Int64")
+    small_ints = pd.Series([-1, 0, 7], dtype="Int64")
+    expected = pd.DataFrame({"bools": bools, "ints": ints, "small_ints": small_ints})
+    tm.assert_frame_equal(result, expected)
+
+
+def test_arrow_load_from_zero_chunks(data):
+    # GH-41040
+
+    df = pd.DataFrame({"a": data[0:0]})
+    table = pa.table(df)
+    assert table.field("a").type == str(data.dtype.numpy_dtype)
+    table = pa.table(
+        [pa.chunked_array([], type=table.field("a").type)], schema=table.schema
+    )
+    result = table.to_pandas()
+    assert result["a"].dtype == data.dtype
+    tm.assert_frame_equal(result, df)
+
+
+def test_arrow_from_arrow_uint():
+    # https://github.com/pandas-dev/pandas/issues/31896
+    # possible mismatch in types
+
+    dtype = pd.UInt32Dtype()
+    result = dtype.__from_arrow__(pa.array([1, 2, 3, 4, None], type="int64"))
+    expected = pd.array([1, 2, 3, 4, None], dtype="UInt32")
+
+    tm.assert_extension_array_equal(result, expected)
+
+
+def test_arrow_sliced(data):
+    # https://github.com/pandas-dev/pandas/issues/38525
+
+    df = pd.DataFrame({"a": data})
+    table = pa.table(df)
+    result = table.slice(2, None).to_pandas()
+    expected = df.iloc[2:].reset_index(drop=True)
+    tm.assert_frame_equal(result, expected)
+
+    # no missing values
+    df2 = df.fillna(data[0])
+    table = pa.table(df2)
+    result = table.slice(2, None).to_pandas()
+    expected = df2.iloc[2:].reset_index(drop=True)
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.fixture
+def np_dtype_to_arrays(any_real_numpy_dtype):
+    """
+    Fixture returning actual and expected dtype, pandas and numpy arrays and
+    mask from a given numpy dtype
+    """
+    np_dtype = np.dtype(any_real_numpy_dtype)
+    pa_type = pa.from_numpy_dtype(np_dtype)
+
+    # None ensures the creation of a bitmask buffer.
+    pa_array = pa.array([0, 1, 2, None], type=pa_type)
+    # Since masked Arrow buffer slots are not required to contain a specific
+    # value, assert only the first three values of the created np.array
+    np_expected = np.array([0, 1, 2], dtype=np_dtype)
+    mask_expected = np.array([True, True, True, False])
+    return np_dtype, pa_array, np_expected, mask_expected
+
+
+def test_pyarrow_array_to_numpy_and_mask(np_dtype_to_arrays):
+    """
+    Test conversion from pyarrow array to numpy array.
+
+    Modifies the pyarrow buffer to contain padding and offset, which are
+    considered valid buffers by pyarrow.
+
+    Also tests empty pyarrow arrays with non empty buffers.
+    See https://github.com/pandas-dev/pandas/issues/40896
+    """
+    np_dtype, pa_array, np_expected, mask_expected = np_dtype_to_arrays
+    data, mask = pyarrow_array_to_numpy_and_mask(pa_array, np_dtype)
+    tm.assert_numpy_array_equal(data[:3], np_expected)
+    tm.assert_numpy_array_equal(mask, mask_expected)
+
+    mask_buffer = pa_array.buffers()[0]
+    data_buffer = pa_array.buffers()[1]
+    data_buffer_bytes = pa_array.buffers()[1].to_pybytes()
+
+    # Add trailing padding to the buffer.
+    data_buffer_trail = pa.py_buffer(data_buffer_bytes + b"\x00")
+    pa_array_trail = pa.Array.from_buffers(
+        type=pa_array.type,
+        length=len(pa_array),
+        buffers=[mask_buffer, data_buffer_trail],
+        offset=pa_array.offset,
+    )
+    pa_array_trail.validate()
+    data, mask = pyarrow_array_to_numpy_and_mask(pa_array_trail, np_dtype)
+    tm.assert_numpy_array_equal(data[:3], np_expected)
+    tm.assert_numpy_array_equal(mask, mask_expected)
+
+    # Add offset to the buffer.
+    offset = b"\x00" * (pa_array.type.bit_width // 8)
+    data_buffer_offset = pa.py_buffer(offset + data_buffer_bytes)
+    mask_buffer_offset = pa.py_buffer(b"\x0E")
+    pa_array_offset = pa.Array.from_buffers(
+        type=pa_array.type,
+        length=len(pa_array),
+        buffers=[mask_buffer_offset, data_buffer_offset],
+        offset=pa_array.offset + 1,
+    )
+    pa_array_offset.validate()
+    data, mask = pyarrow_array_to_numpy_and_mask(pa_array_offset, np_dtype)
+    tm.assert_numpy_array_equal(data[:3], np_expected)
+    tm.assert_numpy_array_equal(mask, mask_expected)
+
+    # Empty array
+    np_expected_empty = np.array([], dtype=np_dtype)
+    mask_expected_empty = np.array([], dtype=np.bool_)
+
+    pa_array_offset = pa.Array.from_buffers(
+        type=pa_array.type,
+        length=0,
+        buffers=[mask_buffer, data_buffer],
+        offset=pa_array.offset,
+    )
+    pa_array_offset.validate()
+    data, mask = pyarrow_array_to_numpy_and_mask(pa_array_offset, np_dtype)
+    tm.assert_numpy_array_equal(data[:3], np_expected_empty)
+    tm.assert_numpy_array_equal(mask, mask_expected_empty)
+
+
+@pytest.mark.parametrize(
+    "arr", [pa.nulls(10), pa.chunked_array([pa.nulls(4), pa.nulls(6)])]
+)
+def test_from_arrow_null(data, arr):
+    res = data.dtype.__from_arrow__(arr)
+    assert res.isna().all()
+    assert len(res) == 10
+
+
+def test_from_arrow_type_error(data):
+    # ensure that __from_arrow__ returns a TypeError when getting a wrong
+    # array type
+
+    arr = pa.array(data).cast("string")
+    with pytest.raises(TypeError, match=None):
+        # we don't test the exact error message, only the fact that it raises
+        # a TypeError is relevant
+        data.dtype.__from_arrow__(arr)

venv/lib/python3.10/site-packages/pandas/tests/arrays/masked/test_function.py

@@ -0,0 +1,74 @@
+import numpy as np
+import pytest
+
+from pandas.core.dtypes.common import is_integer_dtype
+
+import pandas as pd
+import pandas._testing as tm
+from pandas.core.arrays import BaseMaskedArray
+
+arrays = [pd.array([1, 2, 3, None], dtype=dtype) for dtype in tm.ALL_INT_EA_DTYPES]
+arrays += [
+    pd.array([0.141, -0.268, 5.895, None], dtype=dtype) for dtype in tm.FLOAT_EA_DTYPES
+]
+
+
+@pytest.fixture(params=arrays, ids=[a.dtype.name for a in arrays])
+def data(request):
+    """
+    Fixture returning parametrized 'data' array with different integer and
+    floating point types
+    """
+    return request.param
+
+
+@pytest.fixture()
+def numpy_dtype(data):
+    """
+    Fixture returning numpy dtype from 'data' input array.
+    """
+    # For integer dtype, the numpy conversion must be done to float
+    if is_integer_dtype(data):
+        numpy_dtype = float
+    else:
+        numpy_dtype = data.dtype.type
+    return numpy_dtype
+
+
+def test_round(data, numpy_dtype):
+    # No arguments
+    result = data.round()
+    expected = pd.array(
+        np.round(data.to_numpy(dtype=numpy_dtype, na_value=None)), dtype=data.dtype
+    )
+    tm.assert_extension_array_equal(result, expected)
+
+    # Decimals argument
+    result = data.round(decimals=2)
+    expected = pd.array(
+        np.round(data.to_numpy(dtype=numpy_dtype, na_value=None), decimals=2),
+        dtype=data.dtype,
+    )
+    tm.assert_extension_array_equal(result, expected)
+
+
+def test_tolist(data):
+    result = data.tolist()
+    expected = list(data)
+    tm.assert_equal(result, expected)
+
+
+def test_to_numpy():
+    # GH#56991
+
+    class MyStringArray(BaseMaskedArray):
+        dtype = pd.StringDtype()
+        _dtype_cls = pd.StringDtype
+        _internal_fill_value = pd.NA
+
+    arr = MyStringArray(
+        values=np.array(["a", "b", "c"]), mask=np.array([False, True, False])
+    )
+    result = arr.to_numpy()
+    expected = np.array(["a", pd.NA, "c"])
+    tm.assert_numpy_array_equal(result, expected)

venv/lib/python3.10/site-packages/pandas/tests/arrays/masked/test_indexing.py

@@ -0,0 +1,60 @@
+import re
+
+import numpy as np
+import pytest
+
+import pandas as pd
+
+
+class TestSetitemValidation:
+    def _check_setitem_invalid(self, arr, invalid):
+        msg = f"Invalid value '{str(invalid)}' for dtype {arr.dtype}"
+        msg = re.escape(msg)
+        with pytest.raises(TypeError, match=msg):
+            arr[0] = invalid
+
+        with pytest.raises(TypeError, match=msg):
+            arr[:] = invalid
+
+        with pytest.raises(TypeError, match=msg):
+            arr[[0]] = invalid
+
+        # FIXME: don't leave commented-out
+        # with pytest.raises(TypeError):
+        #    arr[[0]] = [invalid]
+
+        # with pytest.raises(TypeError):
+        #    arr[[0]] = np.array([invalid], dtype=object)
+
+        # Series non-coercion, behavior subject to change
+        ser = pd.Series(arr)
+        with pytest.raises(TypeError, match=msg):
+            ser[0] = invalid
+            # TODO: so, so many other variants of this...
+
+    _invalid_scalars = [
+        1 + 2j,
+        "True",
+        "1",
+        "1.0",
+        pd.NaT,
+        np.datetime64("NaT"),
+        np.timedelta64("NaT"),
+    ]
+
+    @pytest.mark.parametrize(
+        "invalid", _invalid_scalars + [1, 1.0, np.int64(1), np.float64(1)]
+    )
+    def test_setitem_validation_scalar_bool(self, invalid):
+        arr = pd.array([True, False, None], dtype="boolean")
+        self._check_setitem_invalid(arr, invalid)
+
+    @pytest.mark.parametrize("invalid", _invalid_scalars + [True, 1.5, np.float64(1.5)])
+    def test_setitem_validation_scalar_int(self, invalid, any_int_ea_dtype):
+        arr = pd.array([1, 2, None], dtype=any_int_ea_dtype)
+        self._check_setitem_invalid(arr, invalid)
+
+    @pytest.mark.parametrize("invalid", _invalid_scalars + [True])
+    def test_setitem_validation_scalar_float(self, invalid, float_ea_dtype):
+        arr = pd.array([1, 2, None], dtype=float_ea_dtype)
+        self._check_setitem_invalid(arr, invalid)

venv/lib/python3.10/site-packages/pandas/tests/arrays/masked_shared.py

@@ -0,0 +1,154 @@
+"""
+Tests shared by MaskedArray subclasses.
+"""
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+from pandas.tests.extension.base import BaseOpsUtil
+
+
+class ComparisonOps(BaseOpsUtil):
+    def _compare_other(self, data, op, other):
+        # array
+        result = pd.Series(op(data, other))
+        expected = pd.Series(op(data._data, other), dtype="boolean")
+
+        # fill the nan locations
+        expected[data._mask] = pd.NA
+
+        tm.assert_series_equal(result, expected)
+
+        # series
+        ser = pd.Series(data)
+        result = op(ser, other)
+
+        # Set nullable dtype here to avoid upcasting when setting to pd.NA below
+        expected = op(pd.Series(data._data), other).astype("boolean")
+
+        # fill the nan locations
+        expected[data._mask] = pd.NA
+
+        tm.assert_series_equal(result, expected)
+
+    # subclass will override to parametrize 'other'
+    def test_scalar(self, other, comparison_op, dtype):
+        op = comparison_op
+        left = pd.array([1, 0, None], dtype=dtype)
+
+        result = op(left, other)
+
+        if other is pd.NA:
+            expected = pd.array([None, None, None], dtype="boolean")
+        else:
+            values = op(left._data, other)
+            expected = pd.arrays.BooleanArray(values, left._mask, copy=True)
+        tm.assert_extension_array_equal(result, expected)
+
+        # ensure we haven't mutated anything inplace
+        result[0] = pd.NA
+        tm.assert_extension_array_equal(left, pd.array([1, 0, None], dtype=dtype))
+
+
+class NumericOps:
+    # Shared by IntegerArray and FloatingArray, not BooleanArray
+
+    def test_searchsorted_nan(self, dtype):
+        # The base class casts to object dtype, for which searchsorted returns
+        #  0 from the left and 10 from the right.
+        arr = pd.array(range(10), dtype=dtype)
+
+        assert arr.searchsorted(np.nan, side="left") == 10
+        assert arr.searchsorted(np.nan, side="right") == 10
+
+    def test_no_shared_mask(self, data):
+        result = data + 1
+        assert not tm.shares_memory(result, data)
+
+    def test_array(self, comparison_op, dtype):
+        op = comparison_op
+
+        left = pd.array([0, 1, 2, None, None, None], dtype=dtype)
+        right = pd.array([0, 1, None, 0, 1, None], dtype=dtype)
+
+        result = op(left, right)
+        values = op(left._data, right._data)
+        mask = left._mask | right._mask
+
+        expected = pd.arrays.BooleanArray(values, mask)
+        tm.assert_extension_array_equal(result, expected)
+
+        # ensure we haven't mutated anything inplace
+        result[0] = pd.NA
+        tm.assert_extension_array_equal(
+            left, pd.array([0, 1, 2, None, None, None], dtype=dtype)
+        )
+        tm.assert_extension_array_equal(
+            right, pd.array([0, 1, None, 0, 1, None], dtype=dtype)
+        )
+
+    def test_compare_with_booleanarray(self, comparison_op, dtype):
+        op = comparison_op
+
+        left = pd.array([True, False, None] * 3, dtype="boolean")
+        right = pd.array([0] * 3 + [1] * 3 + [None] * 3, dtype=dtype)
+        other = pd.array([False] * 3 + [True] * 3 + [None] * 3, dtype="boolean")
+
+        expected = op(left, other)
+        result = op(left, right)
+        tm.assert_extension_array_equal(result, expected)
+
+        # reversed op
+        expected = op(other, left)
+        result = op(right, left)
+        tm.assert_extension_array_equal(result, expected)
+
+    def test_compare_to_string(self, dtype):
+        # GH#28930
+        ser = pd.Series([1, None], dtype=dtype)
+        result = ser == "a"
+        expected = pd.Series([False, pd.NA], dtype="boolean")
+
+        tm.assert_series_equal(result, expected)
+
+    def test_ufunc_with_out(self, dtype):
+        arr = pd.array([1, 2, 3], dtype=dtype)
+        arr2 = pd.array([1, 2, pd.NA], dtype=dtype)
+
+        mask = arr == arr
+        mask2 = arr2 == arr2
+
+        result = np.zeros(3, dtype=bool)
+        result |= mask
+        # If MaskedArray.__array_ufunc__ handled "out" appropriately,
+        #  `result` should still be an ndarray.
+        assert isinstance(result, np.ndarray)
+        assert result.all()
+
+        # result |= mask worked because mask could be cast losslessly to
+        #  boolean ndarray. mask2 can't, so this raises
+        result = np.zeros(3, dtype=bool)
+        msg = "Specify an appropriate 'na_value' for this dtype"
+        with pytest.raises(ValueError, match=msg):
+            result |= mask2
+
+        # addition
+        res = np.add(arr, arr2)
+        expected = pd.array([2, 4, pd.NA], dtype=dtype)
+        tm.assert_extension_array_equal(res, expected)
+
+        # when passing out=arr, we will modify 'arr' inplace.
+        res = np.add(arr, arr2, out=arr)
+        assert res is arr
+        tm.assert_extension_array_equal(res, expected)
+        tm.assert_extension_array_equal(arr, expected)
+
+    def test_mul_td64_array(self, dtype):
+        # GH#45622
+        arr = pd.array([1, 2, pd.NA], dtype=dtype)
+        other = np.arange(3, dtype=np.int64).view("m8[ns]")
+
+        result = arr * other
+        expected = pd.array([pd.Timedelta(0), pd.Timedelta(2), pd.NaT])
+        tm.assert_extension_array_equal(result, expected)

venv/lib/python3.10/site-packages/pandas/tests/arrays/test_array.py

@@ -0,0 +1,478 @@
+import datetime
+import decimal
+import re
+
+import numpy as np
+import pytest
+import pytz
+
+import pandas as pd
+import pandas._testing as tm
+from pandas.api.extensions import register_extension_dtype
+from pandas.arrays import (
+    BooleanArray,
+    DatetimeArray,
+    FloatingArray,
+    IntegerArray,
+    IntervalArray,
+    SparseArray,
+    TimedeltaArray,
+)
+from pandas.core.arrays import (
+    NumpyExtensionArray,
+    period_array,
+)
+from pandas.tests.extension.decimal import (
+    DecimalArray,
+    DecimalDtype,
+    to_decimal,
+)
+
+
+@pytest.mark.parametrize("dtype_unit", ["M8[h]", "M8[m]", "m8[h]", "M8[m]"])
+def test_dt64_array(dtype_unit):
+    # PR 53817
+    dtype_var = np.dtype(dtype_unit)
+    msg = (
+        r"datetime64 and timedelta64 dtype resolutions other than "
+        r"'s', 'ms', 'us', and 'ns' are deprecated. "
+        r"In future releases passing unsupported resolutions will "
+        r"raise an exception."
+    )
+    with tm.assert_produces_warning(FutureWarning, match=re.escape(msg)):
+        pd.array([], dtype=dtype_var)
+
+
+@pytest.mark.parametrize(
+    "data, dtype, expected",
+    [
+        # Basic NumPy defaults.
+        ([], None, FloatingArray._from_sequence([], dtype="Float64")),
+        ([1, 2], None, IntegerArray._from_sequence([1, 2], dtype="Int64")),
+        ([1, 2], object, NumpyExtensionArray(np.array([1, 2], dtype=object))),
+        (
+            [1, 2],
+            np.dtype("float32"),
+            NumpyExtensionArray(np.array([1.0, 2.0], dtype=np.dtype("float32"))),
+        ),
+        (
+            np.array([], dtype=object),
+            None,
+            NumpyExtensionArray(np.array([], dtype=object)),
+        ),
+        (
+            np.array([1, 2], dtype="int64"),
+            None,
+            IntegerArray._from_sequence([1, 2], dtype="Int64"),
+        ),
+        (
+            np.array([1.0, 2.0], dtype="float64"),
+            None,
+            FloatingArray._from_sequence([1.0, 2.0], dtype="Float64"),
+        ),
+        # String alias passes through to NumPy
+        ([1, 2], "float32", NumpyExtensionArray(np.array([1, 2], dtype="float32"))),
+        ([1, 2], "int64", NumpyExtensionArray(np.array([1, 2], dtype=np.int64))),
+        # GH#44715 FloatingArray does not support float16, so fall
+        #  back to NumpyExtensionArray
+        (
+            np.array([1, 2], dtype=np.float16),
+            None,
+            NumpyExtensionArray(np.array([1, 2], dtype=np.float16)),
+        ),
+        # idempotency with e.g. pd.array(pd.array([1, 2], dtype="int64"))
+        (
+            NumpyExtensionArray(np.array([1, 2], dtype=np.int32)),
+            None,
+            NumpyExtensionArray(np.array([1, 2], dtype=np.int32)),
+        ),
+        # Period alias
+        (
+            [pd.Period("2000", "D"), pd.Period("2001", "D")],
+            "Period[D]",
+            period_array(["2000", "2001"], freq="D"),
+        ),
+        # Period dtype
+        (
+            [pd.Period("2000", "D")],
+            pd.PeriodDtype("D"),
+            period_array(["2000"], freq="D"),
+        ),
+        # Datetime (naive)
+        (
+            [1, 2],
+            np.dtype("datetime64[ns]"),
+            DatetimeArray._from_sequence(
+                np.array([1, 2], dtype="M8[ns]"), dtype="M8[ns]"
+            ),
+        ),
+        (
+            [1, 2],
+            np.dtype("datetime64[s]"),
+            DatetimeArray._from_sequence(
+                np.array([1, 2], dtype="M8[s]"), dtype="M8[s]"
+            ),
+        ),
+        (
+            np.array([1, 2], dtype="datetime64[ns]"),
+            None,
+            DatetimeArray._from_sequence(
+                np.array([1, 2], dtype="M8[ns]"), dtype="M8[ns]"
+            ),
+        ),
+        (
+            pd.DatetimeIndex(["2000", "2001"]),
+            np.dtype("datetime64[ns]"),
+            DatetimeArray._from_sequence(["2000", "2001"], dtype="M8[ns]"),
+        ),
+        (
+            pd.DatetimeIndex(["2000", "2001"]),
+            None,
+            DatetimeArray._from_sequence(["2000", "2001"], dtype="M8[ns]"),
+        ),
+        (
+            ["2000", "2001"],
+            np.dtype("datetime64[ns]"),
+            DatetimeArray._from_sequence(["2000", "2001"], dtype="M8[ns]"),
+        ),
+        # Datetime (tz-aware)
+        (
+            ["2000", "2001"],
+            pd.DatetimeTZDtype(tz="CET"),
+            DatetimeArray._from_sequence(
+                ["2000", "2001"], dtype=pd.DatetimeTZDtype(tz="CET")
+            ),
+        ),
+        # Timedelta
+        (
+            ["1h", "2h"],
+            np.dtype("timedelta64[ns]"),
+            TimedeltaArray._from_sequence(["1h", "2h"], dtype="m8[ns]"),
+        ),
+        (
+            pd.TimedeltaIndex(["1h", "2h"]),
+            np.dtype("timedelta64[ns]"),
+            TimedeltaArray._from_sequence(["1h", "2h"], dtype="m8[ns]"),
+        ),
+        (
+            np.array([1, 2], dtype="m8[s]"),
+            np.dtype("timedelta64[s]"),
+            TimedeltaArray._from_sequence(
+                np.array([1, 2], dtype="m8[s]"), dtype="m8[s]"
+            ),
+        ),
+        (
+            pd.TimedeltaIndex(["1h", "2h"]),
+            None,
+            TimedeltaArray._from_sequence(["1h", "2h"], dtype="m8[ns]"),
+        ),
+        (
+            # preserve non-nano, i.e. don't cast to NumpyExtensionArray
+            TimedeltaArray._simple_new(
+                np.arange(5, dtype=np.int64).view("m8[s]"), dtype=np.dtype("m8[s]")
+            ),
+            None,
+            TimedeltaArray._simple_new(
+                np.arange(5, dtype=np.int64).view("m8[s]"), dtype=np.dtype("m8[s]")
+            ),
+        ),
+        (
+            # preserve non-nano, i.e. don't cast to NumpyExtensionArray
+            TimedeltaArray._simple_new(
+                np.arange(5, dtype=np.int64).view("m8[s]"), dtype=np.dtype("m8[s]")
+            ),
+            np.dtype("m8[s]"),
+            TimedeltaArray._simple_new(
+                np.arange(5, dtype=np.int64).view("m8[s]"), dtype=np.dtype("m8[s]")
+            ),
+        ),
+        # Category
+        (["a", "b"], "category", pd.Categorical(["a", "b"])),
+        (
+            ["a", "b"],
+            pd.CategoricalDtype(None, ordered=True),
+            pd.Categorical(["a", "b"], ordered=True),
+        ),
+        # Interval
+        (
+            [pd.Interval(1, 2), pd.Interval(3, 4)],
+            "interval",
+            IntervalArray.from_tuples([(1, 2), (3, 4)]),
+        ),
+        # Sparse
+        ([0, 1], "Sparse[int64]", SparseArray([0, 1], dtype="int64")),
+        # IntegerNA
+        ([1, None], "Int16", pd.array([1, None], dtype="Int16")),
+        (
+            pd.Series([1, 2]),
+            None,
+            NumpyExtensionArray(np.array([1, 2], dtype=np.int64)),
+        ),
+        # String
+        (
+            ["a", None],
+            "string",
+            pd.StringDtype()
+            .construct_array_type()
+            ._from_sequence(["a", None], dtype=pd.StringDtype()),
+        ),
+        (
+            ["a", None],
+            pd.StringDtype(),
+            pd.StringDtype()
+            .construct_array_type()
+            ._from_sequence(["a", None], dtype=pd.StringDtype()),
+        ),
+        # Boolean
+        (
+            [True, None],
+            "boolean",
+            BooleanArray._from_sequence([True, None], dtype="boolean"),
+        ),
+        (
+            [True, None],
+            pd.BooleanDtype(),
+            BooleanArray._from_sequence([True, None], dtype="boolean"),
+        ),
+        # Index
+        (pd.Index([1, 2]), None, NumpyExtensionArray(np.array([1, 2], dtype=np.int64))),
+        # Series[EA] returns the EA
+        (
+            pd.Series(pd.Categorical(["a", "b"], categories=["a", "b", "c"])),
+            None,
+            pd.Categorical(["a", "b"], categories=["a", "b", "c"]),
+        ),
+        # "3rd party" EAs work
+        ([decimal.Decimal(0), decimal.Decimal(1)], "decimal", to_decimal([0, 1])),
+        # pass an ExtensionArray, but a different dtype
+        (
+            period_array(["2000", "2001"], freq="D"),
+            "category",
+            pd.Categorical([pd.Period("2000", "D"), pd.Period("2001", "D")]),
+        ),
+    ],
+)
+def test_array(data, dtype, expected):
+    result = pd.array(data, dtype=dtype)
+    tm.assert_equal(result, expected)
+
+
+def test_array_copy():
+    a = np.array([1, 2])
+    # default is to copy
+    b = pd.array(a, dtype=a.dtype)
+    assert not tm.shares_memory(a, b)
+
+    # copy=True
+    b = pd.array(a, dtype=a.dtype, copy=True)
+    assert not tm.shares_memory(a, b)
+
+    # copy=False
+    b = pd.array(a, dtype=a.dtype, copy=False)
+    assert tm.shares_memory(a, b)
+
+
+cet = pytz.timezone("CET")
+
+
+@pytest.mark.parametrize(
+    "data, expected",
+    [
+        # period
+        (
+            [pd.Period("2000", "D"), pd.Period("2001", "D")],
+            period_array(["2000", "2001"], freq="D"),
+        ),
+        # interval
+        ([pd.Interval(0, 1), pd.Interval(1, 2)], IntervalArray.from_breaks([0, 1, 2])),
+        # datetime
+        (
+            [pd.Timestamp("2000"), pd.Timestamp("2001")],
+            DatetimeArray._from_sequence(["2000", "2001"], dtype="M8[ns]"),
+        ),
+        (
+            [datetime.datetime(2000, 1, 1), datetime.datetime(2001, 1, 1)],
+            DatetimeArray._from_sequence(["2000", "2001"], dtype="M8[ns]"),
+        ),
+        (
+            np.array([1, 2], dtype="M8[ns]"),
+            DatetimeArray._from_sequence(np.array([1, 2], dtype="M8[ns]")),
+        ),
+        (
+            np.array([1, 2], dtype="M8[us]"),
+            DatetimeArray._simple_new(
+                np.array([1, 2], dtype="M8[us]"), dtype=np.dtype("M8[us]")
+            ),
+        ),
+        # datetimetz
+        (
+            [pd.Timestamp("2000", tz="CET"), pd.Timestamp("2001", tz="CET")],
+            DatetimeArray._from_sequence(
+                ["2000", "2001"], dtype=pd.DatetimeTZDtype(tz="CET", unit="ns")
+            ),
+        ),
+        (
+            [
+                datetime.datetime(2000, 1, 1, tzinfo=cet),
+                datetime.datetime(2001, 1, 1, tzinfo=cet),
+            ],
+            DatetimeArray._from_sequence(
+                ["2000", "2001"], dtype=pd.DatetimeTZDtype(tz=cet, unit="ns")
+            ),
+        ),
+        # timedelta
+        (
+            [pd.Timedelta("1h"), pd.Timedelta("2h")],
+            TimedeltaArray._from_sequence(["1h", "2h"], dtype="m8[ns]"),
+        ),
+        (
+            np.array([1, 2], dtype="m8[ns]"),
+            TimedeltaArray._from_sequence(np.array([1, 2], dtype="m8[ns]")),
+        ),
+        (
+            np.array([1, 2], dtype="m8[us]"),
+            TimedeltaArray._from_sequence(np.array([1, 2], dtype="m8[us]")),
+        ),
+        # integer
+        ([1, 2], IntegerArray._from_sequence([1, 2], dtype="Int64")),
+        ([1, None], IntegerArray._from_sequence([1, None], dtype="Int64")),
+        ([1, pd.NA], IntegerArray._from_sequence([1, pd.NA], dtype="Int64")),
+        ([1, np.nan], IntegerArray._from_sequence([1, np.nan], dtype="Int64")),
+        # float
+        ([0.1, 0.2], FloatingArray._from_sequence([0.1, 0.2], dtype="Float64")),
+        ([0.1, None], FloatingArray._from_sequence([0.1, pd.NA], dtype="Float64")),
+        ([0.1, np.nan], FloatingArray._from_sequence([0.1, pd.NA], dtype="Float64")),
+        ([0.1, pd.NA], FloatingArray._from_sequence([0.1, pd.NA], dtype="Float64")),
+        # integer-like float
+        ([1.0, 2.0], FloatingArray._from_sequence([1.0, 2.0], dtype="Float64")),
+        ([1.0, None], FloatingArray._from_sequence([1.0, pd.NA], dtype="Float64")),
+        ([1.0, np.nan], FloatingArray._from_sequence([1.0, pd.NA], dtype="Float64")),
+        ([1.0, pd.NA], FloatingArray._from_sequence([1.0, pd.NA], dtype="Float64")),
+        # mixed-integer-float
+        ([1, 2.0], FloatingArray._from_sequence([1.0, 2.0], dtype="Float64")),
+        (
+            [1, np.nan, 2.0],
+            FloatingArray._from_sequence([1.0, None, 2.0], dtype="Float64"),
+        ),
+        # string
+        (
+            ["a", "b"],
+            pd.StringDtype()
+            .construct_array_type()
+            ._from_sequence(["a", "b"], dtype=pd.StringDtype()),
+        ),
+        (
+            ["a", None],
+            pd.StringDtype()
+            .construct_array_type()
+            ._from_sequence(["a", None], dtype=pd.StringDtype()),
+        ),
+        # Boolean
+        ([True, False], BooleanArray._from_sequence([True, False], dtype="boolean")),
+        ([True, None], BooleanArray._from_sequence([True, None], dtype="boolean")),
+    ],
+)
+def test_array_inference(data, expected):
+    result = pd.array(data)
+    tm.assert_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "data",
+    [
+        # mix of frequencies
+        [pd.Period("2000", "D"), pd.Period("2001", "Y")],
+        # mix of closed
+        [pd.Interval(0, 1, closed="left"), pd.Interval(1, 2, closed="right")],
+        # Mix of timezones
+        [pd.Timestamp("2000", tz="CET"), pd.Timestamp("2000", tz="UTC")],
+        # Mix of tz-aware and tz-naive
+        [pd.Timestamp("2000", tz="CET"), pd.Timestamp("2000")],
+        np.array([pd.Timestamp("2000"), pd.Timestamp("2000", tz="CET")]),
+    ],
+)
+def test_array_inference_fails(data):
+    result = pd.array(data)
+    expected = NumpyExtensionArray(np.array(data, dtype=object))
+    tm.assert_extension_array_equal(result, expected)
+
+
+@pytest.mark.parametrize("data", [np.array(0)])
+def test_nd_raises(data):
+    with pytest.raises(ValueError, match="NumpyExtensionArray must be 1-dimensional"):
+        pd.array(data, dtype="int64")
+
+
+def test_scalar_raises():
+    with pytest.raises(ValueError, match="Cannot pass scalar '1'"):
+        pd.array(1)
+
+
+def test_dataframe_raises():
+    # GH#51167 don't accidentally cast to StringArray by doing inference on columns
+    df = pd.DataFrame([[1, 2], [3, 4]], columns=["A", "B"])
+    msg = "Cannot pass DataFrame to 'pandas.array'"
+    with pytest.raises(TypeError, match=msg):
+        pd.array(df)
+
+
+def test_bounds_check():
+    # GH21796
+    with pytest.raises(
+        TypeError, match=r"cannot safely cast non-equivalent int(32|64) to uint16"
+    ):
+        pd.array([-1, 2, 3], dtype="UInt16")
+
+
+# ---------------------------------------------------------------------------
+# A couple dummy classes to ensure that Series and Indexes are unboxed before
+# getting to the EA classes.
+
+
+@register_extension_dtype
+class DecimalDtype2(DecimalDtype):
+    name = "decimal2"
+
+    @classmethod
+    def construct_array_type(cls):
+        """
+        Return the array type associated with this dtype.
+
+        Returns
+        -------
+        type
+        """
+        return DecimalArray2
+
+
+class DecimalArray2(DecimalArray):
+    @classmethod
+    def _from_sequence(cls, scalars, *, dtype=None, copy=False):
+        if isinstance(scalars, (pd.Series, pd.Index)):
+            raise TypeError("scalars should not be of type pd.Series or pd.Index")
+
+        return super()._from_sequence(scalars, dtype=dtype, copy=copy)
+
+
+def test_array_unboxes(index_or_series):
+    box = index_or_series
+
+    data = box([decimal.Decimal("1"), decimal.Decimal("2")])
+    dtype = DecimalDtype2()
+    # make sure it works
+    with pytest.raises(
+        TypeError, match="scalars should not be of type pd.Series or pd.Index"
+    ):
+        DecimalArray2._from_sequence(data, dtype=dtype)
+
+    result = pd.array(data, dtype="decimal2")
+    expected = DecimalArray2._from_sequence(data.values, dtype=dtype)
+    tm.assert_equal(result, expected)
+
+
+def test_array_to_numpy_na():
+    # GH#40638
+    arr = pd.array([pd.NA, 1], dtype="string[python]")
+    result = arr.to_numpy(na_value=True, dtype=bool)
+    expected = np.array([True, True])
+    tm.assert_numpy_array_equal(result, expected)

venv/lib/python3.10/site-packages/pandas/tests/arrays/test_datetimelike.py

@@ -0,0 +1,1340 @@
+from __future__ import annotations
+
+import re
+import warnings
+
+import numpy as np
+import pytest
+
+from pandas._libs import (
+    NaT,
+    OutOfBoundsDatetime,
+    Timestamp,
+)
+from pandas._libs.tslibs.dtypes import freq_to_period_freqstr
+from pandas.compat.numpy import np_version_gt2
+
+import pandas as pd
+from pandas import (
+    DatetimeIndex,
+    Period,
+    PeriodIndex,
+    TimedeltaIndex,
+)
+import pandas._testing as tm
+from pandas.core.arrays import (
+    DatetimeArray,
+    NumpyExtensionArray,
+    PeriodArray,
+    TimedeltaArray,
+)
+
+
+# TODO: more freq variants
+@pytest.fixture(params=["D", "B", "W", "ME", "QE", "YE"])
+def freqstr(request):
+    """Fixture returning parametrized frequency in string format."""
+    return request.param
+
+
+@pytest.fixture
+def period_index(freqstr):
+    """
+    A fixture to provide PeriodIndex objects with different frequencies.
+
+    Most PeriodArray behavior is already tested in PeriodIndex tests,
+    so here we just test that the PeriodArray behavior matches
+    the PeriodIndex behavior.
+    """
+    # TODO: non-monotone indexes; NaTs, different start dates
+    with warnings.catch_warnings():
+        # suppress deprecation of Period[B]
+        warnings.filterwarnings(
+            "ignore", message="Period with BDay freq", category=FutureWarning
+        )
+        freqstr = freq_to_period_freqstr(1, freqstr)
+        pi = pd.period_range(start=Timestamp("2000-01-01"), periods=100, freq=freqstr)
+    return pi
+
+
+@pytest.fixture
+def datetime_index(freqstr):
+    """
+    A fixture to provide DatetimeIndex objects with different frequencies.
+
+    Most DatetimeArray behavior is already tested in DatetimeIndex tests,
+    so here we just test that the DatetimeArray behavior matches
+    the DatetimeIndex behavior.
+    """
+    # TODO: non-monotone indexes; NaTs, different start dates, timezones
+    dti = pd.date_range(start=Timestamp("2000-01-01"), periods=100, freq=freqstr)
+    return dti
+
+
+@pytest.fixture
+def timedelta_index():
+    """
+    A fixture to provide TimedeltaIndex objects with different frequencies.
+     Most TimedeltaArray behavior is already tested in TimedeltaIndex tests,
+    so here we just test that the TimedeltaArray behavior matches
+    the TimedeltaIndex behavior.
+    """
+    # TODO: flesh this out
+    return TimedeltaIndex(["1 Day", "3 Hours", "NaT"])
+
+
+class SharedTests:
+    index_cls: type[DatetimeIndex | PeriodIndex | TimedeltaIndex]
+
+    @pytest.fixture
+    def arr1d(self):
+        """Fixture returning DatetimeArray with daily frequency."""
+        data = np.arange(10, dtype="i8") * 24 * 3600 * 10**9
+        if self.array_cls is PeriodArray:
+            arr = self.array_cls(data, freq="D")
+        else:
+            arr = self.index_cls(data, freq="D")._data
+        return arr
+
+    def test_compare_len1_raises(self, arr1d):
+        # make sure we raise when comparing with different lengths, specific
+        #  to the case where one has length-1, which numpy would broadcast
+        arr = arr1d
+        idx = self.index_cls(arr)
+
+        with pytest.raises(ValueError, match="Lengths must match"):
+            arr == arr[:1]
+
+        # test the index classes while we're at it, GH#23078
+        with pytest.raises(ValueError, match="Lengths must match"):
+            idx <= idx[[0]]
+
+    @pytest.mark.parametrize(
+        "result",
+        [
+            pd.date_range("2020", periods=3),
+            pd.date_range("2020", periods=3, tz="UTC"),
+            pd.timedelta_range("0 days", periods=3),
+            pd.period_range("2020Q1", periods=3, freq="Q"),
+        ],
+    )
+    def test_compare_with_Categorical(self, result):
+        expected = pd.Categorical(result)
+        assert all(result == expected)
+        assert not any(result != expected)
+
+    @pytest.mark.parametrize("reverse", [True, False])
+    @pytest.mark.parametrize("as_index", [True, False])
+    def test_compare_categorical_dtype(self, arr1d, as_index, reverse, ordered):
+        other = pd.Categorical(arr1d, ordered=ordered)
+        if as_index:
+            other = pd.CategoricalIndex(other)
+
+        left, right = arr1d, other
+        if reverse:
+            left, right = right, left
+
+        ones = np.ones(arr1d.shape, dtype=bool)
+        zeros = ~ones
+
+        result = left == right
+        tm.assert_numpy_array_equal(result, ones)
+
+        result = left != right
+        tm.assert_numpy_array_equal(result, zeros)
+
+        if not reverse and not as_index:
+            # Otherwise Categorical raises TypeError bc it is not ordered
+            # TODO: we should probably get the same behavior regardless?
+            result = left < right
+            tm.assert_numpy_array_equal(result, zeros)
+
+            result = left <= right
+            tm.assert_numpy_array_equal(result, ones)
+
+            result = left > right
+            tm.assert_numpy_array_equal(result, zeros)
+
+            result = left >= right
+            tm.assert_numpy_array_equal(result, ones)
+
+    def test_take(self):
+        data = np.arange(100, dtype="i8") * 24 * 3600 * 10**9
+        np.random.default_rng(2).shuffle(data)
+
+        if self.array_cls is PeriodArray:
+            arr = PeriodArray(data, dtype="period[D]")
+        else:
+            arr = self.index_cls(data)._data
+        idx = self.index_cls._simple_new(arr)
+
+        takers = [1, 4, 94]
+        result = arr.take(takers)
+        expected = idx.take(takers)
+
+        tm.assert_index_equal(self.index_cls(result), expected)
+
+        takers = np.array([1, 4, 94])
+        result = arr.take(takers)
+        expected = idx.take(takers)
+
+        tm.assert_index_equal(self.index_cls(result), expected)
+
+    @pytest.mark.parametrize("fill_value", [2, 2.0, Timestamp(2021, 1, 1, 12).time])
+    def test_take_fill_raises(self, fill_value, arr1d):
+        msg = f"value should be a '{arr1d._scalar_type.__name__}' or 'NaT'. Got"
+        with pytest.raises(TypeError, match=msg):
+            arr1d.take([0, 1], allow_fill=True, fill_value=fill_value)
+
+    def test_take_fill(self, arr1d):
+        arr = arr1d
+
+        result = arr.take([-1, 1], allow_fill=True, fill_value=None)
+        assert result[0] is NaT
+
+        result = arr.take([-1, 1], allow_fill=True, fill_value=np.nan)
+        assert result[0] is NaT
+
+        result = arr.take([-1, 1], allow_fill=True, fill_value=NaT)
+        assert result[0] is NaT
+
+    @pytest.mark.filterwarnings(
+        "ignore:Period with BDay freq is deprecated:FutureWarning"
+    )
+    def test_take_fill_str(self, arr1d):
+        # Cast str fill_value matching other fill_value-taking methods
+        result = arr1d.take([-1, 1], allow_fill=True, fill_value=str(arr1d[-1]))
+        expected = arr1d[[-1, 1]]
+        tm.assert_equal(result, expected)
+
+        msg = f"value should be a '{arr1d._scalar_type.__name__}' or 'NaT'. Got"
+        with pytest.raises(TypeError, match=msg):
+            arr1d.take([-1, 1], allow_fill=True, fill_value="foo")
+
+    def test_concat_same_type(self, arr1d):
+        arr = arr1d
+        idx = self.index_cls(arr)
+        idx = idx.insert(0, NaT)
+        arr = arr1d
+
+        result = arr._concat_same_type([arr[:-1], arr[1:], arr])
+        arr2 = arr.astype(object)
+        expected = self.index_cls(np.concatenate([arr2[:-1], arr2[1:], arr2]))
+
+        tm.assert_index_equal(self.index_cls(result), expected)
+
+    def test_unbox_scalar(self, arr1d):
+        result = arr1d._unbox_scalar(arr1d[0])
+        expected = arr1d._ndarray.dtype.type
+        assert isinstance(result, expected)
+
+        result = arr1d._unbox_scalar(NaT)
+        assert isinstance(result, expected)
+
+        msg = f"'value' should be a {self.scalar_type.__name__}."
+        with pytest.raises(ValueError, match=msg):
+            arr1d._unbox_scalar("foo")
+
+    def test_check_compatible_with(self, arr1d):
+        arr1d._check_compatible_with(arr1d[0])
+        arr1d._check_compatible_with(arr1d[:1])
+        arr1d._check_compatible_with(NaT)
+
+    def test_scalar_from_string(self, arr1d):
+        result = arr1d._scalar_from_string(str(arr1d[0]))
+        assert result == arr1d[0]
+
+    def test_reduce_invalid(self, arr1d):
+        msg = "does not support reduction 'not a method'"
+        with pytest.raises(TypeError, match=msg):
+            arr1d._reduce("not a method")
+
+    @pytest.mark.parametrize("method", ["pad", "backfill"])
+    def test_fillna_method_doesnt_change_orig(self, method):
+        data = np.arange(10, dtype="i8") * 24 * 3600 * 10**9
+        if self.array_cls is PeriodArray:
+            arr = self.array_cls(data, dtype="period[D]")
+        else:
+            arr = self.array_cls._from_sequence(data)
+        arr[4] = NaT
+
+        fill_value = arr[3] if method == "pad" else arr[5]
+
+        result = arr._pad_or_backfill(method=method)
+        assert result[4] == fill_value
+
+        # check that the original was not changed
+        assert arr[4] is NaT
+
+    def test_searchsorted(self):
+        data = np.arange(10, dtype="i8") * 24 * 3600 * 10**9
+        if self.array_cls is PeriodArray:
+            arr = self.array_cls(data, dtype="period[D]")
+        else:
+            arr = self.array_cls._from_sequence(data)
+
+        # scalar
+        result = arr.searchsorted(arr[1])
+        assert result == 1
+
+        result = arr.searchsorted(arr[2], side="right")
+        assert result == 3
+
+        # own-type
+        result = arr.searchsorted(arr[1:3])
+        expected = np.array([1, 2], dtype=np.intp)
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = arr.searchsorted(arr[1:3], side="right")
+        expected = np.array([2, 3], dtype=np.intp)
+        tm.assert_numpy_array_equal(result, expected)
+
+        # GH#29884 match numpy convention on whether NaT goes
+        #  at the end or the beginning
+        result = arr.searchsorted(NaT)
+        assert result == 10
+
+    @pytest.mark.parametrize("box", [None, "index", "series"])
+    def test_searchsorted_castable_strings(self, arr1d, box, string_storage):
+        arr = arr1d
+        if box is None:
+            pass
+        elif box == "index":
+            # Test the equivalent Index.searchsorted method while we're here
+            arr = self.index_cls(arr)
+        else:
+            # Test the equivalent Series.searchsorted method while we're here
+            arr = pd.Series(arr)
+
+        # scalar
+        result = arr.searchsorted(str(arr[1]))
+        assert result == 1
+
+        result = arr.searchsorted(str(arr[2]), side="right")
+        assert result == 3
+
+        result = arr.searchsorted([str(x) for x in arr[1:3]])
+        expected = np.array([1, 2], dtype=np.intp)
+        tm.assert_numpy_array_equal(result, expected)
+
+        with pytest.raises(
+            TypeError,
+            match=re.escape(
+                f"value should be a '{arr1d._scalar_type.__name__}', 'NaT', "
+                "or array of those. Got 'str' instead."
+            ),
+        ):
+            arr.searchsorted("foo")
+
+        with pd.option_context("string_storage", string_storage):
+            with pytest.raises(
+                TypeError,
+                match=re.escape(
+                    f"value should be a '{arr1d._scalar_type.__name__}', 'NaT', "
+                    "or array of those. Got string array instead."
+                ),
+            ):
+                arr.searchsorted([str(arr[1]), "baz"])
+
+    def test_getitem_near_implementation_bounds(self):
+        # We only check tz-naive for DTA bc the bounds are slightly different
+        #  for other tzs
+        i8vals = np.asarray([NaT._value + n for n in range(1, 5)], dtype="i8")
+        if self.array_cls is PeriodArray:
+            arr = self.array_cls(i8vals, dtype="period[ns]")
+        else:
+            arr = self.index_cls(i8vals, freq="ns")._data
+        arr[0]  # should not raise OutOfBoundsDatetime
+
+        index = pd.Index(arr)
+        index[0]  # should not raise OutOfBoundsDatetime
+
+        ser = pd.Series(arr)
+        ser[0]  # should not raise OutOfBoundsDatetime
+
+    def test_getitem_2d(self, arr1d):
+        # 2d slicing on a 1D array
+        expected = type(arr1d)._simple_new(
+            arr1d._ndarray[:, np.newaxis], dtype=arr1d.dtype
+        )
+        result = arr1d[:, np.newaxis]
+        tm.assert_equal(result, expected)
+
+        # Lookup on a 2D array
+        arr2d = expected
+        expected = type(arr2d)._simple_new(arr2d._ndarray[:3, 0], dtype=arr2d.dtype)
+        result = arr2d[:3, 0]
+        tm.assert_equal(result, expected)
+
+        # Scalar lookup
+        result = arr2d[-1, 0]
+        expected = arr1d[-1]
+        assert result == expected
+
+    def test_iter_2d(self, arr1d):
+        data2d = arr1d._ndarray[:3, np.newaxis]
+        arr2d = type(arr1d)._simple_new(data2d, dtype=arr1d.dtype)
+        result = list(arr2d)
+        assert len(result) == 3
+        for x in result:
+            assert isinstance(x, type(arr1d))
+            assert x.ndim == 1
+            assert x.dtype == arr1d.dtype
+
+    def test_repr_2d(self, arr1d):
+        data2d = arr1d._ndarray[:3, np.newaxis]
+        arr2d = type(arr1d)._simple_new(data2d, dtype=arr1d.dtype)
+
+        result = repr(arr2d)
+
+        if isinstance(arr2d, TimedeltaArray):
+            expected = (
+                f"<{type(arr2d).__name__}>\n"
+                "[\n"
+                f"['{arr1d[0]._repr_base()}'],\n"
+                f"['{arr1d[1]._repr_base()}'],\n"
+                f"['{arr1d[2]._repr_base()}']\n"
+                "]\n"
+                f"Shape: (3, 1), dtype: {arr1d.dtype}"
+            )
+        else:
+            expected = (
+                f"<{type(arr2d).__name__}>\n"
+                "[\n"
+                f"['{arr1d[0]}'],\n"
+                f"['{arr1d[1]}'],\n"
+                f"['{arr1d[2]}']\n"
+                "]\n"
+                f"Shape: (3, 1), dtype: {arr1d.dtype}"
+            )
+
+        assert result == expected
+
+    def test_setitem(self):
+        data = np.arange(10, dtype="i8") * 24 * 3600 * 10**9
+        if self.array_cls is PeriodArray:
+            arr = self.array_cls(data, dtype="period[D]")
+        else:
+            arr = self.index_cls(data, freq="D")._data
+
+        arr[0] = arr[1]
+        expected = np.arange(10, dtype="i8") * 24 * 3600 * 10**9
+        expected[0] = expected[1]
+
+        tm.assert_numpy_array_equal(arr.asi8, expected)
+
+        arr[:2] = arr[-2:]
+        expected[:2] = expected[-2:]
+        tm.assert_numpy_array_equal(arr.asi8, expected)
+
+    @pytest.mark.parametrize(
+        "box",
+        [
+            pd.Index,
+            pd.Series,
+            np.array,
+            list,
+            NumpyExtensionArray,
+        ],
+    )
+    def test_setitem_object_dtype(self, box, arr1d):
+        expected = arr1d.copy()[::-1]
+        if expected.dtype.kind in ["m", "M"]:
+            expected = expected._with_freq(None)
+
+        vals = expected
+        if box is list:
+            vals = list(vals)
+        elif box is np.array:
+            # if we do np.array(x).astype(object) then dt64 and td64 cast to ints
+            vals = np.array(vals.astype(object))
+        elif box is NumpyExtensionArray:
+            vals = box(np.asarray(vals, dtype=object))
+        else:
+            vals = box(vals).astype(object)
+
+        arr1d[:] = vals
+
+        tm.assert_equal(arr1d, expected)
+
+    def test_setitem_strs(self, arr1d):
+        # Check that we parse strs in both scalar and listlike
+
+        # Setting list-like of strs
+        expected = arr1d.copy()
+        expected[[0, 1]] = arr1d[-2:]
+
+        result = arr1d.copy()
+        result[:2] = [str(x) for x in arr1d[-2:]]
+        tm.assert_equal(result, expected)
+
+        # Same thing but now for just a scalar str
+        expected = arr1d.copy()
+        expected[0] = arr1d[-1]
+
+        result = arr1d.copy()
+        result[0] = str(arr1d[-1])
+        tm.assert_equal(result, expected)
+
+    @pytest.mark.parametrize("as_index", [True, False])
+    def test_setitem_categorical(self, arr1d, as_index):
+        expected = arr1d.copy()[::-1]
+        if not isinstance(expected, PeriodArray):
+            expected = expected._with_freq(None)
+
+        cat = pd.Categorical(arr1d)
+        if as_index:
+            cat = pd.CategoricalIndex(cat)
+
+        arr1d[:] = cat[::-1]
+
+        tm.assert_equal(arr1d, expected)
+
+    def test_setitem_raises(self, arr1d):
+        arr = arr1d[:10]
+        val = arr[0]
+
+        with pytest.raises(IndexError, match="index 12 is out of bounds"):
+            arr[12] = val
+
+        with pytest.raises(TypeError, match="value should be a.* 'object'"):
+            arr[0] = object()
+
+        msg = "cannot set using a list-like indexer with a different length"
+        with pytest.raises(ValueError, match=msg):
+            # GH#36339
+            arr[[]] = [arr[1]]
+
+        msg = "cannot set using a slice indexer with a different length than"
+        with pytest.raises(ValueError, match=msg):
+            # GH#36339
+            arr[1:1] = arr[:3]
+
+    @pytest.mark.parametrize("box", [list, np.array, pd.Index, pd.Series])
+    def test_setitem_numeric_raises(self, arr1d, box):
+        # We dont case e.g. int64 to our own dtype for setitem
+
+        msg = (
+            f"value should be a '{arr1d._scalar_type.__name__}', "
+            "'NaT', or array of those. Got"
+        )
+        with pytest.raises(TypeError, match=msg):
+            arr1d[:2] = box([0, 1])
+
+        with pytest.raises(TypeError, match=msg):
+            arr1d[:2] = box([0.0, 1.0])
+
+    def test_inplace_arithmetic(self):
+        # GH#24115 check that iadd and isub are actually in-place
+        data = np.arange(10, dtype="i8") * 24 * 3600 * 10**9
+        if self.array_cls is PeriodArray:
+            arr = self.array_cls(data, dtype="period[D]")
+        else:
+            arr = self.index_cls(data, freq="D")._data
+
+        expected = arr + pd.Timedelta(days=1)
+        arr += pd.Timedelta(days=1)
+        tm.assert_equal(arr, expected)
+
+        expected = arr - pd.Timedelta(days=1)
+        arr -= pd.Timedelta(days=1)
+        tm.assert_equal(arr, expected)
+
+    def test_shift_fill_int_deprecated(self, arr1d):
+        # GH#31971, enforced in 2.0
+        with pytest.raises(TypeError, match="value should be a"):
+            arr1d.shift(1, fill_value=1)
+
+    def test_median(self, arr1d):
+        arr = arr1d
+        if len(arr) % 2 == 0:
+            # make it easier to define `expected`
+            arr = arr[:-1]
+
+        expected = arr[len(arr) // 2]
+
+        result = arr.median()
+        assert type(result) is type(expected)
+        assert result == expected
+
+        arr[len(arr) // 2] = NaT
+        if not isinstance(expected, Period):
+            expected = arr[len(arr) // 2 - 1 : len(arr) // 2 + 2].mean()
+
+        assert arr.median(skipna=False) is NaT
+
+        result = arr.median()
+        assert type(result) is type(expected)
+        assert result == expected
+
+        assert arr[:0].median() is NaT
+        assert arr[:0].median(skipna=False) is NaT
+
+        # 2d Case
+        arr2 = arr.reshape(-1, 1)
+
+        result = arr2.median(axis=None)
+        assert type(result) is type(expected)
+        assert result == expected
+
+        assert arr2.median(axis=None, skipna=False) is NaT
+
+        result = arr2.median(axis=0)
+        expected2 = type(arr)._from_sequence([expected], dtype=arr.dtype)
+        tm.assert_equal(result, expected2)
+
+        result = arr2.median(axis=0, skipna=False)
+        expected2 = type(arr)._from_sequence([NaT], dtype=arr.dtype)
+        tm.assert_equal(result, expected2)
+
+        result = arr2.median(axis=1)
+        tm.assert_equal(result, arr)
+
+        result = arr2.median(axis=1, skipna=False)
+        tm.assert_equal(result, arr)
+
+    def test_from_integer_array(self):
+        arr = np.array([1, 2, 3], dtype=np.int64)
+        data = pd.array(arr, dtype="Int64")
+        if self.array_cls is PeriodArray:
+            expected = self.array_cls(arr, dtype=self.example_dtype)
+            result = self.array_cls(data, dtype=self.example_dtype)
+        else:
+            expected = self.array_cls._from_sequence(arr, dtype=self.example_dtype)
+            result = self.array_cls._from_sequence(data, dtype=self.example_dtype)
+
+        tm.assert_extension_array_equal(result, expected)
+
+
+class TestDatetimeArray(SharedTests):
+    index_cls = DatetimeIndex
+    array_cls = DatetimeArray
+    scalar_type = Timestamp
+    example_dtype = "M8[ns]"
+
+    @pytest.fixture
+    def arr1d(self, tz_naive_fixture, freqstr):
+        """
+        Fixture returning DatetimeArray with parametrized frequency and
+        timezones
+        """
+        tz = tz_naive_fixture
+        dti = pd.date_range("2016-01-01 01:01:00", periods=5, freq=freqstr, tz=tz)
+        dta = dti._data
+        return dta
+
+    def test_round(self, arr1d):
+        # GH#24064
+        dti = self.index_cls(arr1d)
+
+        result = dti.round(freq="2min")
+        expected = dti - pd.Timedelta(minutes=1)
+        expected = expected._with_freq(None)
+        tm.assert_index_equal(result, expected)
+
+        dta = dti._data
+        result = dta.round(freq="2min")
+        expected = expected._data._with_freq(None)
+        tm.assert_datetime_array_equal(result, expected)
+
+    def test_array_interface(self, datetime_index):
+        arr = datetime_index._data
+        copy_false = None if np_version_gt2 else False
+
+        # default asarray gives the same underlying data (for tz naive)
+        result = np.asarray(arr)
+        expected = arr._ndarray
+        assert result is expected
+        tm.assert_numpy_array_equal(result, expected)
+        result = np.array(arr, copy=copy_false)
+        assert result is expected
+        tm.assert_numpy_array_equal(result, expected)
+
+        # specifying M8[ns] gives the same result as default
+        result = np.asarray(arr, dtype="datetime64[ns]")
+        expected = arr._ndarray
+        assert result is expected
+        tm.assert_numpy_array_equal(result, expected)
+        result = np.array(arr, dtype="datetime64[ns]", copy=copy_false)
+        assert result is expected
+        tm.assert_numpy_array_equal(result, expected)
+        result = np.array(arr, dtype="datetime64[ns]")
+        assert result is not expected
+        tm.assert_numpy_array_equal(result, expected)
+
+        # to object dtype
+        result = np.asarray(arr, dtype=object)
+        expected = np.array(list(arr), dtype=object)
+        tm.assert_numpy_array_equal(result, expected)
+
+        # to other dtype always copies
+        result = np.asarray(arr, dtype="int64")
+        assert result is not arr.asi8
+        assert not np.may_share_memory(arr, result)
+        expected = arr.asi8.copy()
+        tm.assert_numpy_array_equal(result, expected)
+
+        # other dtypes handled by numpy
+        for dtype in ["float64", str]:
+            result = np.asarray(arr, dtype=dtype)
+            expected = np.asarray(arr).astype(dtype)
+            tm.assert_numpy_array_equal(result, expected)
+
+    def test_array_object_dtype(self, arr1d):
+        # GH#23524
+        arr = arr1d
+        dti = self.index_cls(arr1d)
+
+        expected = np.array(list(dti))
+
+        result = np.array(arr, dtype=object)
+        tm.assert_numpy_array_equal(result, expected)
+
+        # also test the DatetimeIndex method while we're at it
+        result = np.array(dti, dtype=object)
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_array_tz(self, arr1d):
+        # GH#23524
+        arr = arr1d
+        dti = self.index_cls(arr1d)
+        copy_false = None if np_version_gt2 else False
+
+        expected = dti.asi8.view("M8[ns]")
+        result = np.array(arr, dtype="M8[ns]")
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = np.array(arr, dtype="datetime64[ns]")
+        tm.assert_numpy_array_equal(result, expected)
+
+        # check that we are not making copies when setting copy=copy_false
+        result = np.array(arr, dtype="M8[ns]", copy=copy_false)
+        assert result.base is expected.base
+        assert result.base is not None
+        result = np.array(arr, dtype="datetime64[ns]", copy=copy_false)
+        assert result.base is expected.base
+        assert result.base is not None
+
+    def test_array_i8_dtype(self, arr1d):
+        arr = arr1d
+        dti = self.index_cls(arr1d)
+        copy_false = None if np_version_gt2 else False
+
+        expected = dti.asi8
+        result = np.array(arr, dtype="i8")
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = np.array(arr, dtype=np.int64)
+        tm.assert_numpy_array_equal(result, expected)
+
+        # check that we are still making copies when setting copy=copy_false
+        result = np.array(arr, dtype="i8", copy=copy_false)
+        assert result.base is not expected.base
+        assert result.base is None
+
+    def test_from_array_keeps_base(self):
+        # Ensure that DatetimeArray._ndarray.base isn't lost.
+        arr = np.array(["2000-01-01", "2000-01-02"], dtype="M8[ns]")
+        dta = DatetimeArray._from_sequence(arr)
+
+        assert dta._ndarray is arr
+        dta = DatetimeArray._from_sequence(arr[:0])
+        assert dta._ndarray.base is arr
+
+    def test_from_dti(self, arr1d):
+        arr = arr1d
+        dti = self.index_cls(arr1d)
+        assert list(dti) == list(arr)
+
+        # Check that Index.__new__ knows what to do with DatetimeArray
+        dti2 = pd.Index(arr)
+        assert isinstance(dti2, DatetimeIndex)
+        assert list(dti2) == list(arr)
+
+    def test_astype_object(self, arr1d):
+        arr = arr1d
+        dti = self.index_cls(arr1d)
+
+        asobj = arr.astype("O")
+        assert isinstance(asobj, np.ndarray)
+        assert asobj.dtype == "O"
+        assert list(asobj) == list(dti)
+
+    @pytest.mark.filterwarnings(r"ignore:PeriodDtype\[B\] is deprecated:FutureWarning")
+    def test_to_period(self, datetime_index, freqstr):
+        dti = datetime_index
+        arr = dti._data
+
+        freqstr = freq_to_period_freqstr(1, freqstr)
+        expected = dti.to_period(freq=freqstr)
+        result = arr.to_period(freq=freqstr)
+        assert isinstance(result, PeriodArray)
+
+        tm.assert_equal(result, expected._data)
+
+    def test_to_period_2d(self, arr1d):
+        arr2d = arr1d.reshape(1, -1)
+
+        warn = None if arr1d.tz is None else UserWarning
+        with tm.assert_produces_warning(warn):
+            result = arr2d.to_period("D")
+            expected = arr1d.to_period("D").reshape(1, -1)
+        tm.assert_period_array_equal(result, expected)
+
+    @pytest.mark.parametrize("propname", DatetimeArray._bool_ops)
+    def test_bool_properties(self, arr1d, propname):
+        # in this case _bool_ops is just `is_leap_year`
+        dti = self.index_cls(arr1d)
+        arr = arr1d
+        assert dti.freq == arr.freq
+
+        result = getattr(arr, propname)
+        expected = np.array(getattr(dti, propname), dtype=result.dtype)
+
+        tm.assert_numpy_array_equal(result, expected)
+
+    @pytest.mark.parametrize("propname", DatetimeArray._field_ops)
+    def test_int_properties(self, arr1d, propname):
+        dti = self.index_cls(arr1d)
+        arr = arr1d
+
+        result = getattr(arr, propname)
+        expected = np.array(getattr(dti, propname), dtype=result.dtype)
+
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_take_fill_valid(self, arr1d, fixed_now_ts):
+        arr = arr1d
+        dti = self.index_cls(arr1d)
+
+        now = fixed_now_ts.tz_localize(dti.tz)
+        result = arr.take([-1, 1], allow_fill=True, fill_value=now)
+        assert result[0] == now
+
+        msg = f"value should be a '{arr1d._scalar_type.__name__}' or 'NaT'. Got"
+        with pytest.raises(TypeError, match=msg):
+            # fill_value Timedelta invalid
+            arr.take([-1, 1], allow_fill=True, fill_value=now - now)
+
+        with pytest.raises(TypeError, match=msg):
+            # fill_value Period invalid
+            arr.take([-1, 1], allow_fill=True, fill_value=Period("2014Q1"))
+
+        tz = None if dti.tz is not None else "US/Eastern"
+        now = fixed_now_ts.tz_localize(tz)
+        msg = "Cannot compare tz-naive and tz-aware datetime-like objects"
+        with pytest.raises(TypeError, match=msg):
+            # Timestamp with mismatched tz-awareness
+            arr.take([-1, 1], allow_fill=True, fill_value=now)
+
+        value = NaT._value
+        msg = f"value should be a '{arr1d._scalar_type.__name__}' or 'NaT'. Got"
+        with pytest.raises(TypeError, match=msg):
+            # require NaT, not iNaT, as it could be confused with an integer
+            arr.take([-1, 1], allow_fill=True, fill_value=value)
+
+        value = np.timedelta64("NaT", "ns")
+        with pytest.raises(TypeError, match=msg):
+            # require appropriate-dtype if we have a NA value
+            arr.take([-1, 1], allow_fill=True, fill_value=value)
+
+        if arr.tz is not None:
+            # GH#37356
+            # Assuming here that arr1d fixture does not include Australia/Melbourne
+            value = fixed_now_ts.tz_localize("Australia/Melbourne")
+            result = arr.take([-1, 1], allow_fill=True, fill_value=value)
+
+            expected = arr.take(
+                [-1, 1],
+                allow_fill=True,
+                fill_value=value.tz_convert(arr.dtype.tz),
+            )
+            tm.assert_equal(result, expected)
+
+    def test_concat_same_type_invalid(self, arr1d):
+        # different timezones
+        arr = arr1d
+
+        if arr.tz is None:
+            other = arr.tz_localize("UTC")
+        else:
+            other = arr.tz_localize(None)
+
+        with pytest.raises(ValueError, match="to_concat must have the same"):
+            arr._concat_same_type([arr, other])
+
+    def test_concat_same_type_different_freq(self, unit):
+        # we *can* concatenate DTI with different freqs.
+        a = pd.date_range("2000", periods=2, freq="D", tz="US/Central", unit=unit)._data
+        b = pd.date_range("2000", periods=2, freq="h", tz="US/Central", unit=unit)._data
+        result = DatetimeArray._concat_same_type([a, b])
+        expected = (
+            pd.to_datetime(
+                [
+                    "2000-01-01 00:00:00",
+                    "2000-01-02 00:00:00",
+                    "2000-01-01 00:00:00",
+                    "2000-01-01 01:00:00",
+                ]
+            )
+            .tz_localize("US/Central")
+            .as_unit(unit)
+            ._data
+        )
+
+        tm.assert_datetime_array_equal(result, expected)
+
+    def test_strftime(self, arr1d):
+        arr = arr1d
+
+        result = arr.strftime("%Y %b")
+        expected = np.array([ts.strftime("%Y %b") for ts in arr], dtype=object)
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_strftime_nat(self):
+        # GH 29578
+        arr = DatetimeIndex(["2019-01-01", NaT])._data
+
+        result = arr.strftime("%Y-%m-%d")
+        expected = np.array(["2019-01-01", np.nan], dtype=object)
+        tm.assert_numpy_array_equal(result, expected)
+
+
+class TestTimedeltaArray(SharedTests):
+    index_cls = TimedeltaIndex
+    array_cls = TimedeltaArray
+    scalar_type = pd.Timedelta
+    example_dtype = "m8[ns]"
+
+    def test_from_tdi(self):
+        tdi = TimedeltaIndex(["1 Day", "3 Hours"])
+        arr = tdi._data
+        assert list(arr) == list(tdi)
+
+        # Check that Index.__new__ knows what to do with TimedeltaArray
+        tdi2 = pd.Index(arr)
+        assert isinstance(tdi2, TimedeltaIndex)
+        assert list(tdi2) == list(arr)
+
+    def test_astype_object(self):
+        tdi = TimedeltaIndex(["1 Day", "3 Hours"])
+        arr = tdi._data
+        asobj = arr.astype("O")
+        assert isinstance(asobj, np.ndarray)
+        assert asobj.dtype == "O"
+        assert list(asobj) == list(tdi)
+
+    def test_to_pytimedelta(self, timedelta_index):
+        tdi = timedelta_index
+        arr = tdi._data
+
+        expected = tdi.to_pytimedelta()
+        result = arr.to_pytimedelta()
+
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_total_seconds(self, timedelta_index):
+        tdi = timedelta_index
+        arr = tdi._data
+
+        expected = tdi.total_seconds()
+        result = arr.total_seconds()
+
+        tm.assert_numpy_array_equal(result, expected.values)
+
+    @pytest.mark.parametrize("propname", TimedeltaArray._field_ops)
+    def test_int_properties(self, timedelta_index, propname):
+        tdi = timedelta_index
+        arr = tdi._data
+
+        result = getattr(arr, propname)
+        expected = np.array(getattr(tdi, propname), dtype=result.dtype)
+
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_array_interface(self, timedelta_index):
+        arr = timedelta_index._data
+        copy_false = None if np_version_gt2 else False
+
+        # default asarray gives the same underlying data
+        result = np.asarray(arr)
+        expected = arr._ndarray
+        assert result is expected
+        tm.assert_numpy_array_equal(result, expected)
+        result = np.array(arr, copy=copy_false)
+        assert result is expected
+        tm.assert_numpy_array_equal(result, expected)
+
+        # specifying m8[ns] gives the same result as default
+        result = np.asarray(arr, dtype="timedelta64[ns]")
+        expected = arr._ndarray
+        assert result is expected
+        tm.assert_numpy_array_equal(result, expected)
+        result = np.array(arr, dtype="timedelta64[ns]", copy=copy_false)
+        assert result is expected
+        tm.assert_numpy_array_equal(result, expected)
+        result = np.array(arr, dtype="timedelta64[ns]")
+        assert result is not expected
+        tm.assert_numpy_array_equal(result, expected)
+
+        # to object dtype
+        result = np.asarray(arr, dtype=object)
+        expected = np.array(list(arr), dtype=object)
+        tm.assert_numpy_array_equal(result, expected)
+
+        # to other dtype always copies
+        result = np.asarray(arr, dtype="int64")
+        assert result is not arr.asi8
+        assert not np.may_share_memory(arr, result)
+        expected = arr.asi8.copy()
+        tm.assert_numpy_array_equal(result, expected)
+
+        # other dtypes handled by numpy
+        for dtype in ["float64", str]:
+            result = np.asarray(arr, dtype=dtype)
+            expected = np.asarray(arr).astype(dtype)
+            tm.assert_numpy_array_equal(result, expected)
+
+    def test_take_fill_valid(self, timedelta_index, fixed_now_ts):
+        tdi = timedelta_index
+        arr = tdi._data
+
+        td1 = pd.Timedelta(days=1)
+        result = arr.take([-1, 1], allow_fill=True, fill_value=td1)
+        assert result[0] == td1
+
+        value = fixed_now_ts
+        msg = f"value should be a '{arr._scalar_type.__name__}' or 'NaT'. Got"
+        with pytest.raises(TypeError, match=msg):
+            # fill_value Timestamp invalid
+            arr.take([0, 1], allow_fill=True, fill_value=value)
+
+        value = fixed_now_ts.to_period("D")
+        with pytest.raises(TypeError, match=msg):
+            # fill_value Period invalid
+            arr.take([0, 1], allow_fill=True, fill_value=value)
+
+        value = np.datetime64("NaT", "ns")
+        with pytest.raises(TypeError, match=msg):
+            # require appropriate-dtype if we have a NA value
+            arr.take([-1, 1], allow_fill=True, fill_value=value)
+
+
+@pytest.mark.filterwarnings(r"ignore:Period with BDay freq is deprecated:FutureWarning")
+@pytest.mark.filterwarnings(r"ignore:PeriodDtype\[B\] is deprecated:FutureWarning")
+class TestPeriodArray(SharedTests):
+    index_cls = PeriodIndex
+    array_cls = PeriodArray
+    scalar_type = Period
+    example_dtype = PeriodIndex([], freq="W").dtype
+
+    @pytest.fixture
+    def arr1d(self, period_index):
+        """
+        Fixture returning DatetimeArray from parametrized PeriodIndex objects
+        """
+        return period_index._data
+
+    def test_from_pi(self, arr1d):
+        pi = self.index_cls(arr1d)
+        arr = arr1d
+        assert list(arr) == list(pi)
+
+        # Check that Index.__new__ knows what to do with PeriodArray
+        pi2 = pd.Index(arr)
+        assert isinstance(pi2, PeriodIndex)
+        assert list(pi2) == list(arr)
+
+    def test_astype_object(self, arr1d):
+        pi = self.index_cls(arr1d)
+        arr = arr1d
+        asobj = arr.astype("O")
+        assert isinstance(asobj, np.ndarray)
+        assert asobj.dtype == "O"
+        assert list(asobj) == list(pi)
+
+    def test_take_fill_valid(self, arr1d):
+        arr = arr1d
+
+        value = NaT._value
+        msg = f"value should be a '{arr1d._scalar_type.__name__}' or 'NaT'. Got"
+        with pytest.raises(TypeError, match=msg):
+            # require NaT, not iNaT, as it could be confused with an integer
+            arr.take([-1, 1], allow_fill=True, fill_value=value)
+
+        value = np.timedelta64("NaT", "ns")
+        with pytest.raises(TypeError, match=msg):
+            # require appropriate-dtype if we have a NA value
+            arr.take([-1, 1], allow_fill=True, fill_value=value)
+
+    @pytest.mark.parametrize("how", ["S", "E"])
+    def test_to_timestamp(self, how, arr1d):
+        pi = self.index_cls(arr1d)
+        arr = arr1d
+
+        expected = DatetimeIndex(pi.to_timestamp(how=how))._data
+        result = arr.to_timestamp(how=how)
+        assert isinstance(result, DatetimeArray)
+
+        tm.assert_equal(result, expected)
+
+    def test_to_timestamp_roundtrip_bday(self):
+        # Case where infer_freq inside would choose "D" instead of "B"
+        dta = pd.date_range("2021-10-18", periods=3, freq="B")._data
+        parr = dta.to_period()
+        result = parr.to_timestamp()
+        assert result.freq == "B"
+        tm.assert_extension_array_equal(result, dta)
+
+        dta2 = dta[::2]
+        parr2 = dta2.to_period()
+        result2 = parr2.to_timestamp()
+        assert result2.freq == "2B"
+        tm.assert_extension_array_equal(result2, dta2)
+
+        parr3 = dta.to_period("2B")
+        result3 = parr3.to_timestamp()
+        assert result3.freq == "B"
+        tm.assert_extension_array_equal(result3, dta)
+
+    def test_to_timestamp_out_of_bounds(self):
+        # GH#19643 previously overflowed silently
+        pi = pd.period_range("1500", freq="Y", periods=3)
+        msg = "Out of bounds nanosecond timestamp: 1500-01-01 00:00:00"
+        with pytest.raises(OutOfBoundsDatetime, match=msg):
+            pi.to_timestamp()
+
+        with pytest.raises(OutOfBoundsDatetime, match=msg):
+            pi._data.to_timestamp()
+
+    @pytest.mark.parametrize("propname", PeriodArray._bool_ops)
+    def test_bool_properties(self, arr1d, propname):
+        # in this case _bool_ops is just `is_leap_year`
+        pi = self.index_cls(arr1d)
+        arr = arr1d
+
+        result = getattr(arr, propname)
+        expected = np.array(getattr(pi, propname))
+
+        tm.assert_numpy_array_equal(result, expected)
+
+    @pytest.mark.parametrize("propname", PeriodArray._field_ops)
+    def test_int_properties(self, arr1d, propname):
+        pi = self.index_cls(arr1d)
+        arr = arr1d
+
+        result = getattr(arr, propname)
+        expected = np.array(getattr(pi, propname))
+
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_array_interface(self, arr1d):
+        arr = arr1d
+
+        # default asarray gives objects
+        result = np.asarray(arr)
+        expected = np.array(list(arr), dtype=object)
+        tm.assert_numpy_array_equal(result, expected)
+
+        # to object dtype (same as default)
+        result = np.asarray(arr, dtype=object)
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = np.asarray(arr, dtype="int64")
+        tm.assert_numpy_array_equal(result, arr.asi8)
+
+        # to other dtypes
+        msg = r"float\(\) argument must be a string or a( real)? number, not 'Period'"
+        with pytest.raises(TypeError, match=msg):
+            np.asarray(arr, dtype="float64")
+
+        result = np.asarray(arr, dtype="S20")
+        expected = np.asarray(arr).astype("S20")
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_strftime(self, arr1d):
+        arr = arr1d
+
+        result = arr.strftime("%Y")
+        expected = np.array([per.strftime("%Y") for per in arr], dtype=object)
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_strftime_nat(self):
+        # GH 29578
+        arr = PeriodArray(PeriodIndex(["2019-01-01", NaT], dtype="period[D]"))
+
+        result = arr.strftime("%Y-%m-%d")
+        expected = np.array(["2019-01-01", np.nan], dtype=object)
+        tm.assert_numpy_array_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "arr,casting_nats",
+    [
+        (
+            TimedeltaIndex(["1 Day", "3 Hours", "NaT"])._data,
+            (NaT, np.timedelta64("NaT", "ns")),
+        ),
+        (
+            pd.date_range("2000-01-01", periods=3, freq="D")._data,
+            (NaT, np.datetime64("NaT", "ns")),
+        ),
+        (pd.period_range("2000-01-01", periods=3, freq="D")._data, (NaT,)),
+    ],
+    ids=lambda x: type(x).__name__,
+)
+def test_casting_nat_setitem_array(arr, casting_nats):
+    expected = type(arr)._from_sequence([NaT, arr[1], arr[2]], dtype=arr.dtype)
+
+    for nat in casting_nats:
+        arr = arr.copy()
+        arr[0] = nat
+        tm.assert_equal(arr, expected)
+
+
+@pytest.mark.parametrize(
+    "arr,non_casting_nats",
+    [
+        (
+            TimedeltaIndex(["1 Day", "3 Hours", "NaT"])._data,
+            (np.datetime64("NaT", "ns"), NaT._value),
+        ),
+        (
+            pd.date_range("2000-01-01", periods=3, freq="D")._data,
+            (np.timedelta64("NaT", "ns"), NaT._value),
+        ),
+        (
+            pd.period_range("2000-01-01", periods=3, freq="D")._data,
+            (np.datetime64("NaT", "ns"), np.timedelta64("NaT", "ns"), NaT._value),
+        ),
+    ],
+    ids=lambda x: type(x).__name__,
+)
+def test_invalid_nat_setitem_array(arr, non_casting_nats):
+    msg = (
+        "value should be a '(Timestamp|Timedelta|Period)', 'NaT', or array of those. "
+        "Got '(timedelta64|datetime64|int)' instead."
+    )
+
+    for nat in non_casting_nats:
+        with pytest.raises(TypeError, match=msg):
+            arr[0] = nat
+
+
+@pytest.mark.parametrize(
+    "arr",
+    [
+        pd.date_range("2000", periods=4).array,
+        pd.timedelta_range("2000", periods=4).array,
+    ],
+)
+def test_to_numpy_extra(arr):
+    arr[0] = NaT
+    original = arr.copy()
+
+    result = arr.to_numpy()
+    assert np.isnan(result[0])
+
+    result = arr.to_numpy(dtype="int64")
+    assert result[0] == -9223372036854775808
+
+    result = arr.to_numpy(dtype="int64", na_value=0)
+    assert result[0] == 0
+
+    result = arr.to_numpy(na_value=arr[1].to_numpy())
+    assert result[0] == result[1]
+
+    result = arr.to_numpy(na_value=arr[1].to_numpy(copy=False))
+    assert result[0] == result[1]
+
+    tm.assert_equal(arr, original)
+
+
+@pytest.mark.parametrize("as_index", [True, False])
+@pytest.mark.parametrize(
+    "values",
+    [
+        pd.to_datetime(["2020-01-01", "2020-02-01"]),
+        pd.to_timedelta([1, 2], unit="D"),
+        PeriodIndex(["2020-01-01", "2020-02-01"], freq="D"),
+    ],
+)
+@pytest.mark.parametrize(
+    "klass",
+    [
+        list,
+        np.array,
+        pd.array,
+        pd.Series,
+        pd.Index,
+        pd.Categorical,
+        pd.CategoricalIndex,
+    ],
+)
+def test_searchsorted_datetimelike_with_listlike(values, klass, as_index):
+    # https://github.com/pandas-dev/pandas/issues/32762
+    if not as_index:
+        values = values._data
+
+    result = values.searchsorted(klass(values))
+    expected = np.array([0, 1], dtype=result.dtype)
+
+    tm.assert_numpy_array_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "values",
+    [
+        pd.to_datetime(["2020-01-01", "2020-02-01"]),
+        pd.to_timedelta([1, 2], unit="D"),
+        PeriodIndex(["2020-01-01", "2020-02-01"], freq="D"),
+    ],
+)
+@pytest.mark.parametrize(
+    "arg", [[1, 2], ["a", "b"], [Timestamp("2020-01-01", tz="Europe/London")] * 2]
+)
+def test_searchsorted_datetimelike_with_listlike_invalid_dtype(values, arg):
+    # https://github.com/pandas-dev/pandas/issues/32762
+    msg = "[Unexpected type|Cannot compare]"
+    with pytest.raises(TypeError, match=msg):
+        values.searchsorted(arg)
+
+
+@pytest.mark.parametrize("klass", [list, tuple, np.array, pd.Series])
+def test_period_index_construction_from_strings(klass):
+    # https://github.com/pandas-dev/pandas/issues/26109
+    strings = ["2020Q1", "2020Q2"] * 2
+    data = klass(strings)
+    result = PeriodIndex(data, freq="Q")
+    expected = PeriodIndex([Period(s) for s in strings])
+    tm.assert_index_equal(result, expected)
+
+
+@pytest.mark.parametrize("dtype", ["M8[ns]", "m8[ns]"])
+def test_from_pandas_array(dtype):
+    # GH#24615
+    data = np.array([1, 2, 3], dtype=dtype)
+    arr = NumpyExtensionArray(data)
+
+    cls = {"M8[ns]": DatetimeArray, "m8[ns]": TimedeltaArray}[dtype]
+
+    depr_msg = f"{cls.__name__}.__init__ is deprecated"
+    with tm.assert_produces_warning(FutureWarning, match=depr_msg):
+        result = cls(arr)
+        expected = cls(data)
+    tm.assert_extension_array_equal(result, expected)
+
+    result = cls._from_sequence(arr, dtype=dtype)
+    expected = cls._from_sequence(data, dtype=dtype)
+    tm.assert_extension_array_equal(result, expected)
+
+    func = {"M8[ns]": pd.to_datetime, "m8[ns]": pd.to_timedelta}[dtype]
+    result = func(arr).array
+    expected = func(data).array
+    tm.assert_equal(result, expected)
+
+    # Let's check the Indexes while we're here
+    idx_cls = {"M8[ns]": DatetimeIndex, "m8[ns]": TimedeltaIndex}[dtype]
+    result = idx_cls(arr)
+    expected = idx_cls(data)
+    tm.assert_index_equal(result, expected)