Add files using upload-large-folder tool

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

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:163e02a237da82f144fc1024f84d195c18ccdc31ff7c654a8a82571cec6f7c7d
+size 41830148

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

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

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

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

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

@@ -0,0 +1,68 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas.core.arrays.integer import (
+    Int8Dtype,
+    Int16Dtype,
+    Int32Dtype,
+    Int64Dtype,
+    UInt8Dtype,
+    UInt16Dtype,
+    UInt32Dtype,
+    UInt64Dtype,
+)
+
+
+@pytest.fixture(
+    params=[
+        Int8Dtype,
+        Int16Dtype,
+        Int32Dtype,
+        Int64Dtype,
+        UInt8Dtype,
+        UInt16Dtype,
+        UInt32Dtype,
+        UInt64Dtype,
+    ]
+)
+def dtype(request):
+    """Parametrized fixture returning integer 'dtype'"""
+    return request.param()
+
+
+@pytest.fixture
+def data(dtype):
+    """
+    Fixture returning 'data' array with valid and missing values according to
+    parametrized integer 'dtype'.
+
+    Used to test dtype conversion with and without missing values.
+    """
+    return pd.array(
+        list(range(8)) + [np.nan] + list(range(10, 98)) + [np.nan] + [99, 100],
+        dtype=dtype,
+    )
+
+
+@pytest.fixture
+def data_missing(dtype):
+    """
+    Fixture returning array with exactly one NaN and one valid integer,
+    according to parametrized integer 'dtype'.
+
+    Used to test dtype conversion with and without missing values.
+    """
+    return pd.array([np.nan, 1], dtype=dtype)
+
+
+@pytest.fixture(params=["data", "data_missing"])
+def all_data(request, data, data_missing):
+    """Parametrized fixture returning 'data' or 'data_missing' integer arrays.
+
+    Used to test dtype conversion with and without missing values.
+    """
+    if request.param == "data":
+        return data
+    elif request.param == "data_missing":
+        return data_missing

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

@@ -0,0 +1,385 @@
+import operator
+
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+from pandas.core import ops
+from pandas.core.arrays import FloatingArray
+
+# Basic test for the arithmetic array ops
+# -----------------------------------------------------------------------------
+
+
+@pytest.mark.parametrize(
+    "opname, exp",
+    [("add", [1, 3, None, None, 9]), ("mul", [0, 2, None, None, 20])],
+    ids=["add", "mul"],
+)
+def test_add_mul(dtype, opname, exp):
+    a = pd.array([0, 1, None, 3, 4], dtype=dtype)
+    b = pd.array([1, 2, 3, None, 5], dtype=dtype)
+
+    # array / array
+    expected = pd.array(exp, dtype=dtype)
+
+    op = getattr(operator, opname)
+    result = op(a, b)
+    tm.assert_extension_array_equal(result, expected)
+
+    op = getattr(ops, "r" + opname)
+    result = op(a, b)
+    tm.assert_extension_array_equal(result, expected)
+
+
+def test_sub(dtype):
+    a = pd.array([1, 2, 3, None, 5], dtype=dtype)
+    b = pd.array([0, 1, None, 3, 4], dtype=dtype)
+
+    result = a - b
+    expected = pd.array([1, 1, None, None, 1], dtype=dtype)
+    tm.assert_extension_array_equal(result, expected)
+
+
+def test_div(dtype):
+    a = pd.array([1, 2, 3, None, 5], dtype=dtype)
+    b = pd.array([0, 1, None, 3, 4], dtype=dtype)
+
+    result = a / b
+    expected = pd.array([np.inf, 2, None, None, 1.25], dtype="Float64")
+    tm.assert_extension_array_equal(result, expected)
+
+
+@pytest.mark.parametrize("zero, negative", [(0, False), (0.0, False), (-0.0, True)])
+def test_divide_by_zero(zero, negative):
+    # https://github.com/pandas-dev/pandas/issues/27398, GH#22793
+    a = pd.array([0, 1, -1, None], dtype="Int64")
+    result = a / zero
+    expected = FloatingArray(
+        np.array([np.nan, np.inf, -np.inf, 1], dtype="float64"),
+        np.array([False, False, False, True]),
+    )
+    if negative:
+        expected *= -1
+    tm.assert_extension_array_equal(result, expected)
+
+
+def test_floordiv(dtype):
+    a = pd.array([1, 2, 3, None, 5], dtype=dtype)
+    b = pd.array([0, 1, None, 3, 4], dtype=dtype)
+
+    result = a // b
+    # Series op sets 1//0 to np.inf, which IntegerArray does not do (yet)
+    expected = pd.array([0, 2, None, None, 1], dtype=dtype)
+    tm.assert_extension_array_equal(result, expected)
+
+
+def test_floordiv_by_int_zero_no_mask(any_int_ea_dtype):
+    # GH 48223: Aligns with non-masked floordiv
+    # but differs from numpy
+    # https://github.com/pandas-dev/pandas/issues/30188#issuecomment-564452740
+    ser = pd.Series([0, 1], dtype=any_int_ea_dtype)
+    result = 1 // ser
+    expected = pd.Series([np.inf, 1.0], dtype="Float64")
+    tm.assert_series_equal(result, expected)
+
+    ser_non_nullable = ser.astype(ser.dtype.numpy_dtype)
+    result = 1 // ser_non_nullable
+    expected = expected.astype(np.float64)
+    tm.assert_series_equal(result, expected)
+
+
+def test_mod(dtype):
+    a = pd.array([1, 2, 3, None, 5], dtype=dtype)
+    b = pd.array([0, 1, None, 3, 4], dtype=dtype)
+
+    result = a % b
+    expected = pd.array([0, 0, None, None, 1], dtype=dtype)
+    tm.assert_extension_array_equal(result, expected)
+
+
+def test_pow_scalar():
+    a = pd.array([-1, 0, 1, None, 2], dtype="Int64")
+    result = a**0
+    expected = pd.array([1, 1, 1, 1, 1], dtype="Int64")
+    tm.assert_extension_array_equal(result, expected)
+
+    result = a**1
+    expected = pd.array([-1, 0, 1, None, 2], dtype="Int64")
+    tm.assert_extension_array_equal(result, expected)
+
+    result = a**pd.NA
+    expected = pd.array([None, None, 1, None, None], dtype="Int64")
+    tm.assert_extension_array_equal(result, expected)
+
+    result = a**np.nan
+    expected = FloatingArray(
+        np.array([np.nan, np.nan, 1, np.nan, np.nan], dtype="float64"),
+        np.array([False, False, False, True, False]),
+    )
+    tm.assert_extension_array_equal(result, expected)
+
+    # reversed
+    a = a[1:]  # Can't raise integers to negative powers.
+
+    result = 0**a
+    expected = pd.array([1, 0, None, 0], dtype="Int64")
+    tm.assert_extension_array_equal(result, expected)
+
+    result = 1**a
+    expected = pd.array([1, 1, 1, 1], dtype="Int64")
+    tm.assert_extension_array_equal(result, expected)
+
+    result = pd.NA**a
+    expected = pd.array([1, None, None, None], dtype="Int64")
+    tm.assert_extension_array_equal(result, expected)
+
+    result = np.nan**a
+    expected = FloatingArray(
+        np.array([1, np.nan, np.nan, np.nan], dtype="float64"),
+        np.array([False, False, True, False]),
+    )
+    tm.assert_extension_array_equal(result, expected)
+
+
+def test_pow_array():
+    a = pd.array([0, 0, 0, 1, 1, 1, None, None, None])
+    b = pd.array([0, 1, None, 0, 1, None, 0, 1, None])
+    result = a**b
+    expected = pd.array([1, 0, None, 1, 1, 1, 1, None, None])
+    tm.assert_extension_array_equal(result, expected)
+
+
+def test_rpow_one_to_na():
+    # https://github.com/pandas-dev/pandas/issues/22022
+    # https://github.com/pandas-dev/pandas/issues/29997
+    arr = pd.array([np.nan, np.nan], dtype="Int64")
+    result = np.array([1.0, 2.0]) ** arr
+    expected = pd.array([1.0, np.nan], dtype="Float64")
+    tm.assert_extension_array_equal(result, expected)
+
+
+@pytest.mark.parametrize("other", [0, 0.5])
+def test_numpy_zero_dim_ndarray(other):
+    arr = pd.array([1, None, 2])
+    result = arr + np.array(other)
+    expected = arr + other
+    tm.assert_equal(result, expected)
+
+
+# Test generic characteristics / errors
+# -----------------------------------------------------------------------------
+
+
+def test_error_invalid_values(data, all_arithmetic_operators, using_infer_string):
+    op = all_arithmetic_operators
+    s = pd.Series(data)
+    ops = getattr(s, op)
+
+    if using_infer_string:
+        import pyarrow as pa
+
+        errs = (TypeError, pa.lib.ArrowNotImplementedError, NotImplementedError)
+    else:
+        errs = TypeError
+
+    # invalid scalars
+    msg = "|".join(
+        [
+            r"can only perform ops with numeric values",
+            r"IntegerArray cannot perform the operation mod",
+            r"unsupported operand type",
+            r"can only concatenate str \(not \"int\"\) to str",
+            "not all arguments converted during string",
+            "ufunc '.*' not supported for the input types, and the inputs could not",
+            "ufunc '.*' did not contain a loop with signature matching types",
+            "Addition/subtraction of integers and integer-arrays with Timestamp",
+            "has no kernel",
+            "not implemented",
+            "The 'out' kwarg is necessary. Use numpy.strings.multiply without it.",
+        ]
+    )
+    with pytest.raises(errs, match=msg):
+        ops("foo")
+    with pytest.raises(errs, match=msg):
+        ops(pd.Timestamp("20180101"))
+
+    # invalid array-likes
+    str_ser = pd.Series("foo", index=s.index)
+    # with pytest.raises(TypeError, match=msg):
+    if (
+        all_arithmetic_operators
+        in [
+            "__mul__",
+            "__rmul__",
+        ]
+        and not using_infer_string
+    ):  # (data[~data.isna()] >= 0).all():
+        res = ops(str_ser)
+        expected = pd.Series(["foo" * x for x in data], index=s.index)
+        expected = expected.fillna(np.nan)
+        # TODO: doing this fillna to keep tests passing as we make
+        #  assert_almost_equal stricter, but the expected with pd.NA seems
+        #  more-correct than np.nan here.
+        tm.assert_series_equal(res, expected)
+    else:
+        with pytest.raises(errs, match=msg):
+            ops(str_ser)
+
+    msg = "|".join(
+        [
+            "can only perform ops with numeric values",
+            "cannot perform .* with this index type: DatetimeArray",
+            "Addition/subtraction of integers and integer-arrays "
+            "with DatetimeArray is no longer supported. *",
+            "unsupported operand type",
+            r"can only concatenate str \(not \"int\"\) to str",
+            "not all arguments converted during string",
+            "cannot subtract DatetimeArray from ndarray",
+            "has no kernel",
+            "not implemented",
+        ]
+    )
+    with pytest.raises(errs, match=msg):
+        ops(pd.Series(pd.date_range("20180101", periods=len(s))))
+
+
+# Various
+# -----------------------------------------------------------------------------
+
+
+# TODO test unsigned overflow
+
+
+def test_arith_coerce_scalar(data, all_arithmetic_operators):
+    op = tm.get_op_from_name(all_arithmetic_operators)
+    s = pd.Series(data)
+    other = 0.01
+
+    result = op(s, other)
+    expected = op(s.astype(float), other)
+    expected = expected.astype("Float64")
+
+    # rmod results in NaN that wasn't NA in original nullable Series -> unmask it
+    if all_arithmetic_operators == "__rmod__":
+        mask = (s == 0).fillna(False).to_numpy(bool)
+        expected.array._mask[mask] = False
+
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("other", [1.0, np.array(1.0)])
+def test_arithmetic_conversion(all_arithmetic_operators, other):
+    # if we have a float operand we should have a float result
+    # if that is equal to an integer
+    op = tm.get_op_from_name(all_arithmetic_operators)
+
+    s = pd.Series([1, 2, 3], dtype="Int64")
+    result = op(s, other)
+    assert result.dtype == "Float64"
+
+
+def test_cross_type_arithmetic():
+    df = pd.DataFrame(
+        {
+            "A": pd.Series([1, 2, np.nan], dtype="Int64"),
+            "B": pd.Series([1, np.nan, 3], dtype="UInt8"),
+            "C": [1, 2, 3],
+        }
+    )
+
+    result = df.A + df.C
+    expected = pd.Series([2, 4, np.nan], dtype="Int64")
+    tm.assert_series_equal(result, expected)
+
+    result = (df.A + df.C) * 3 == 12
+    expected = pd.Series([False, True, None], dtype="boolean")
+    tm.assert_series_equal(result, expected)
+
+    result = df.A + df.B
+    expected = pd.Series([2, np.nan, np.nan], dtype="Int64")
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("op", ["mean"])
+def test_reduce_to_float(op):
+    # some reduce ops always return float, even if the result
+    # is a rounded number
+    df = pd.DataFrame(
+        {
+            "A": ["a", "b", "b"],
+            "B": [1, None, 3],
+            "C": pd.array([1, None, 3], dtype="Int64"),
+        }
+    )
+
+    # op
+    result = getattr(df.C, op)()
+    assert isinstance(result, float)
+
+    # groupby
+    result = getattr(df.groupby("A"), op)()
+
+    expected = pd.DataFrame(
+        {"B": np.array([1.0, 3.0]), "C": pd.array([1, 3], dtype="Float64")},
+        index=pd.Index(["a", "b"], name="A"),
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "source, neg_target, abs_target",
+    [
+        ([1, 2, 3], [-1, -2, -3], [1, 2, 3]),
+        ([1, 2, None], [-1, -2, None], [1, 2, None]),
+        ([-1, 0, 1], [1, 0, -1], [1, 0, 1]),
+    ],
+)
+def test_unary_int_operators(any_signed_int_ea_dtype, source, neg_target, abs_target):
+    dtype = any_signed_int_ea_dtype
+    arr = pd.array(source, dtype=dtype)
+    neg_result, pos_result, abs_result = -arr, +arr, abs(arr)
+    neg_target = pd.array(neg_target, dtype=dtype)
+    abs_target = pd.array(abs_target, dtype=dtype)
+
+    tm.assert_extension_array_equal(neg_result, neg_target)
+    tm.assert_extension_array_equal(pos_result, arr)
+    assert not tm.shares_memory(pos_result, arr)
+    tm.assert_extension_array_equal(abs_result, abs_target)
+
+
+def test_values_multiplying_large_series_by_NA():
+    # GH#33701
+
+    result = pd.NA * pd.Series(np.zeros(10001))
+    expected = pd.Series([pd.NA] * 10001)
+
+    tm.assert_series_equal(result, expected)
+
+
+def test_bitwise(dtype):
+    left = pd.array([1, None, 3, 4], dtype=dtype)
+    right = pd.array([None, 3, 5, 4], dtype=dtype)
+
+    result = left | right
+    expected = pd.array([None, None, 3 | 5, 4 | 4], dtype=dtype)
+    tm.assert_extension_array_equal(result, expected)
+
+    result = left & right
+    expected = pd.array([None, None, 3 & 5, 4 & 4], dtype=dtype)
+    tm.assert_extension_array_equal(result, expected)
+
+    result = left ^ right
+    expected = pd.array([None, None, 3 ^ 5, 4 ^ 4], dtype=dtype)
+    tm.assert_extension_array_equal(result, expected)
+
+    # TODO: desired behavior when operating with boolean?  defer?
+
+    floats = right.astype("Float64")
+    with pytest.raises(TypeError, match="unsupported operand type"):
+        left | floats
+    with pytest.raises(TypeError, match="unsupported operand type"):
+        left & floats
+    with pytest.raises(TypeError, match="unsupported operand type"):
+        left ^ floats

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

@@ -0,0 +1,39 @@
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+from pandas.tests.arrays.masked_shared import (
+    ComparisonOps,
+    NumericOps,
+)
+
+
+class TestComparisonOps(NumericOps, ComparisonOps):
+    @pytest.mark.parametrize("other", [True, False, pd.NA, -1, 0, 1])
+    def test_scalar(self, other, comparison_op, dtype):
+        ComparisonOps.test_scalar(self, other, comparison_op, dtype)
+
+    def test_compare_to_int(self, dtype, comparison_op):
+        # GH 28930
+        op_name = f"__{comparison_op.__name__}__"
+        s1 = pd.Series([1, None, 3], dtype=dtype)
+        s2 = pd.Series([1, None, 3], dtype="float")
+
+        method = getattr(s1, op_name)
+        result = method(2)
+
+        method = getattr(s2, op_name)
+        expected = method(2).astype("boolean")
+        expected[s2.isna()] = pd.NA
+
+        tm.assert_series_equal(result, expected)
+
+
+def test_equals():
+    # GH-30652
+    # equals is generally tested in /tests/extension/base/methods, but this
+    # specifically tests that two arrays of the same class but different dtype
+    # do not evaluate equal
+    a1 = pd.array([1, 2, None], dtype="Int64")
+    a2 = pd.array([1, 2, None], dtype="Int32")
+    assert a1.equals(a2) is False

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

@@ -0,0 +1,69 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+
+
+@pytest.mark.parametrize(
+    "to_concat_dtypes, result_dtype",
+    [
+        (["Int64", "Int64"], "Int64"),
+        (["UInt64", "UInt64"], "UInt64"),
+        (["Int8", "Int8"], "Int8"),
+        (["Int8", "Int16"], "Int16"),
+        (["UInt8", "Int8"], "Int16"),
+        (["Int32", "UInt32"], "Int64"),
+        (["Int64", "UInt64"], "Float64"),
+        (["Int64", "boolean"], "object"),
+        (["UInt8", "boolean"], "object"),
+    ],
+)
+def test_concat_series(to_concat_dtypes, result_dtype):
+    # we expect the same dtypes as we would get with non-masked inputs,
+    #  just masked where available.
+
+    result = pd.concat([pd.Series([0, 1, pd.NA], dtype=t) for t in to_concat_dtypes])
+    expected = pd.concat([pd.Series([0, 1, pd.NA], dtype=object)] * 2).astype(
+        result_dtype
+    )
+    tm.assert_series_equal(result, expected)
+
+    # order doesn't matter for result
+    result = pd.concat(
+        [pd.Series([0, 1, pd.NA], dtype=t) for t in to_concat_dtypes[::-1]]
+    )
+    expected = pd.concat([pd.Series([0, 1, pd.NA], dtype=object)] * 2).astype(
+        result_dtype
+    )
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "to_concat_dtypes, result_dtype",
+    [
+        (["Int64", "int64"], "Int64"),
+        (["UInt64", "uint64"], "UInt64"),
+        (["Int8", "int8"], "Int8"),
+        (["Int8", "int16"], "Int16"),
+        (["UInt8", "int8"], "Int16"),
+        (["Int32", "uint32"], "Int64"),
+        (["Int64", "uint64"], "Float64"),
+        (["Int64", "bool"], "object"),
+        (["UInt8", "bool"], "object"),
+    ],
+)
+def test_concat_series_with_numpy(to_concat_dtypes, result_dtype):
+    # we expect the same dtypes as we would get with non-masked inputs,
+    #  just masked where available.
+
+    s1 = pd.Series([0, 1, pd.NA], dtype=to_concat_dtypes[0])
+    s2 = pd.Series(np.array([0, 1], dtype=to_concat_dtypes[1]))
+    result = pd.concat([s1, s2], ignore_index=True)
+    expected = pd.Series([0, 1, pd.NA, 0, 1], dtype=object).astype(result_dtype)
+    tm.assert_series_equal(result, expected)
+
+    # order doesn't matter for result
+    result = pd.concat([s2, s1], ignore_index=True)
+    expected = pd.Series([0, 1, 0, 1, pd.NA], dtype=object).astype(result_dtype)
+    tm.assert_series_equal(result, expected)

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

@@ -0,0 +1,245 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+from pandas.api.types import is_integer
+from pandas.core.arrays import IntegerArray
+from pandas.core.arrays.integer import (
+    Int8Dtype,
+    Int32Dtype,
+    Int64Dtype,
+)
+
+
+@pytest.fixture(params=[pd.array, IntegerArray._from_sequence])
+def constructor(request):
+    """Fixture returning parametrized IntegerArray from given sequence.
+
+    Used to test dtype conversions.
+    """
+    return request.param
+
+
+def test_uses_pandas_na():
+    a = pd.array([1, None], dtype=Int64Dtype())
+    assert a[1] is pd.NA
+
+
+def test_from_dtype_from_float(data):
+    # construct from our dtype & string dtype
+    dtype = data.dtype
+
+    # from float
+    expected = pd.Series(data)
+    result = pd.Series(data.to_numpy(na_value=np.nan, dtype="float"), dtype=str(dtype))
+    tm.assert_series_equal(result, expected)
+
+    # from int / list
+    expected = pd.Series(data)
+    result = pd.Series(np.array(data).tolist(), dtype=str(dtype))
+    tm.assert_series_equal(result, expected)
+
+    # from int / array
+    expected = pd.Series(data).dropna().reset_index(drop=True)
+    dropped = np.array(data.dropna()).astype(np.dtype(dtype.type))
+    result = pd.Series(dropped, dtype=str(dtype))
+    tm.assert_series_equal(result, expected)
+
+
+def test_conversions(data_missing):
+    # astype to object series
+    df = pd.DataFrame({"A": data_missing})
+    result = df["A"].astype("object")
+    expected = pd.Series(np.array([pd.NA, 1], dtype=object), name="A")
+    tm.assert_series_equal(result, expected)
+
+    # convert to object ndarray
+    # we assert that we are exactly equal
+    # including type conversions of scalars
+    result = df["A"].astype("object").values
+    expected = np.array([pd.NA, 1], dtype=object)
+    tm.assert_numpy_array_equal(result, expected)
+
+    for r, e in zip(result, expected):
+        if pd.isnull(r):
+            assert pd.isnull(e)
+        elif is_integer(r):
+            assert r == e
+            assert is_integer(e)
+        else:
+            assert r == e
+            assert type(r) == type(e)
+
+
+def test_integer_array_constructor():
+    values = np.array([1, 2, 3, 4], dtype="int64")
+    mask = np.array([False, False, False, True], dtype="bool")
+
+    result = IntegerArray(values, mask)
+    expected = pd.array([1, 2, 3, np.nan], dtype="Int64")
+    tm.assert_extension_array_equal(result, expected)
+
+    msg = r".* should be .* numpy array. Use the 'pd.array' function instead"
+    with pytest.raises(TypeError, match=msg):
+        IntegerArray(values.tolist(), mask)
+
+    with pytest.raises(TypeError, match=msg):
+        IntegerArray(values, mask.tolist())
+
+    with pytest.raises(TypeError, match=msg):
+        IntegerArray(values.astype(float), mask)
+    msg = r"__init__\(\) missing 1 required positional argument: 'mask'"
+    with pytest.raises(TypeError, match=msg):
+        IntegerArray(values)
+
+
+def test_integer_array_constructor_copy():
+    values = np.array([1, 2, 3, 4], dtype="int64")
+    mask = np.array([False, False, False, True], dtype="bool")
+
+    result = IntegerArray(values, mask)
+    assert result._data is values
+    assert result._mask is mask
+
+    result = IntegerArray(values, mask, copy=True)
+    assert result._data is not values
+    assert result._mask is not mask
+
+
+@pytest.mark.parametrize(
+    "a, b",
+    [
+        ([1, None], [1, np.nan]),
+        ([None], [np.nan]),
+        ([None, np.nan], [np.nan, np.nan]),
+        ([np.nan, np.nan], [np.nan, np.nan]),
+    ],
+)
+def test_to_integer_array_none_is_nan(a, b):
+    result = pd.array(a, dtype="Int64")
+    expected = pd.array(b, dtype="Int64")
+    tm.assert_extension_array_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "values",
+    [
+        ["foo", "bar"],
+        "foo",
+        1,
+        1.0,
+        pd.date_range("20130101", periods=2),
+        np.array(["foo"]),
+        [[1, 2], [3, 4]],
+        [np.nan, {"a": 1}],
+    ],
+)
+def test_to_integer_array_error(values):
+    # error in converting existing arrays to IntegerArrays
+    msg = "|".join(
+        [
+            r"cannot be converted to IntegerDtype",
+            r"invalid literal for int\(\) with base 10:",
+            r"values must be a 1D list-like",
+            r"Cannot pass scalar",
+            r"int\(\) argument must be a string",
+        ]
+    )
+    with pytest.raises((ValueError, TypeError), match=msg):
+        pd.array(values, dtype="Int64")
+
+    with pytest.raises((ValueError, TypeError), match=msg):
+        IntegerArray._from_sequence(values)
+
+
+def test_to_integer_array_inferred_dtype(constructor):
+    # if values has dtype -> respect it
+    result = constructor(np.array([1, 2], dtype="int8"))
+    assert result.dtype == Int8Dtype()
+    result = constructor(np.array([1, 2], dtype="int32"))
+    assert result.dtype == Int32Dtype()
+
+    # if values have no dtype -> always int64
+    result = constructor([1, 2])
+    assert result.dtype == Int64Dtype()
+
+
+def test_to_integer_array_dtype_keyword(constructor):
+    result = constructor([1, 2], dtype="Int8")
+    assert result.dtype == Int8Dtype()
+
+    # if values has dtype -> override it
+    result = constructor(np.array([1, 2], dtype="int8"), dtype="Int32")
+    assert result.dtype == Int32Dtype()
+
+
+def test_to_integer_array_float():
+    result = IntegerArray._from_sequence([1.0, 2.0], dtype="Int64")
+    expected = pd.array([1, 2], dtype="Int64")
+    tm.assert_extension_array_equal(result, expected)
+
+    with pytest.raises(TypeError, match="cannot safely cast non-equivalent"):
+        IntegerArray._from_sequence([1.5, 2.0], dtype="Int64")
+
+    # for float dtypes, the itemsize is not preserved
+    result = IntegerArray._from_sequence(
+        np.array([1.0, 2.0], dtype="float32"), dtype="Int64"
+    )
+    assert result.dtype == Int64Dtype()
+
+
+def test_to_integer_array_str():
+    result = IntegerArray._from_sequence(["1", "2", None], dtype="Int64")
+    expected = pd.array([1, 2, np.nan], dtype="Int64")
+    tm.assert_extension_array_equal(result, expected)
+
+    with pytest.raises(
+        ValueError, match=r"invalid literal for int\(\) with base 10: .*"
+    ):
+        IntegerArray._from_sequence(["1", "2", ""], dtype="Int64")
+
+    with pytest.raises(
+        ValueError, match=r"invalid literal for int\(\) with base 10: .*"
+    ):
+        IntegerArray._from_sequence(["1.5", "2.0"], dtype="Int64")
+
+
+@pytest.mark.parametrize(
+    "bool_values, int_values, target_dtype, expected_dtype",
+    [
+        ([False, True], [0, 1], Int64Dtype(), Int64Dtype()),
+        ([False, True], [0, 1], "Int64", Int64Dtype()),
+        ([False, True, np.nan], [0, 1, np.nan], Int64Dtype(), Int64Dtype()),
+    ],
+)
+def test_to_integer_array_bool(
+    constructor, bool_values, int_values, target_dtype, expected_dtype
+):
+    result = constructor(bool_values, dtype=target_dtype)
+    assert result.dtype == expected_dtype
+    expected = pd.array(int_values, dtype=target_dtype)
+    tm.assert_extension_array_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "values, to_dtype, result_dtype",
+    [
+        (np.array([1], dtype="int64"), None, Int64Dtype),
+        (np.array([1, np.nan]), None, Int64Dtype),
+        (np.array([1, np.nan]), "int8", Int8Dtype),
+    ],
+)
+def test_to_integer_array(values, to_dtype, result_dtype):
+    # convert existing arrays to IntegerArrays
+    result = IntegerArray._from_sequence(values, dtype=to_dtype)
+    assert result.dtype == result_dtype()
+    expected = pd.array(values, dtype=result_dtype())
+    tm.assert_extension_array_equal(result, expected)
+
+
+def test_integer_array_from_boolean():
+    # GH31104
+    expected = pd.array(np.array([True, False]), dtype="Int64")
+    result = pd.array(np.array([True, False], dtype=object), dtype="Int64")
+    tm.assert_extension_array_equal(result, expected)

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

@@ -0,0 +1,294 @@
+import numpy as np
+import pytest
+
+from pandas.core.dtypes.generic import ABCIndex
+
+import pandas as pd
+import pandas._testing as tm
+from pandas.core.arrays.integer import (
+    Int8Dtype,
+    UInt32Dtype,
+)
+
+
+def test_dtypes(dtype):
+    # smoke tests on auto dtype construction
+
+    if dtype.is_signed_integer:
+        assert np.dtype(dtype.type).kind == "i"
+    else:
+        assert np.dtype(dtype.type).kind == "u"
+    assert dtype.name is not None
+
+
+@pytest.mark.parametrize("op", ["sum", "min", "max", "prod"])
+def test_preserve_dtypes(op):
+    # for ops that enable (mean would actually work here
+    # but generally it is a float return value)
+    df = pd.DataFrame(
+        {
+            "A": ["a", "b", "b"],
+            "B": [1, None, 3],
+            "C": pd.array([1, None, 3], dtype="Int64"),
+        }
+    )
+
+    # op
+    result = getattr(df.C, op)()
+    if op in {"sum", "prod", "min", "max"}:
+        assert isinstance(result, np.int64)
+    else:
+        assert isinstance(result, int)
+
+    # groupby
+    result = getattr(df.groupby("A"), op)()
+
+    expected = pd.DataFrame(
+        {"B": np.array([1.0, 3.0]), "C": pd.array([1, 3], dtype="Int64")},
+        index=pd.Index(["a", "b"], name="A"),
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_astype_nansafe():
+    # see gh-22343
+    arr = pd.array([np.nan, 1, 2], dtype="Int8")
+    msg = "cannot convert NA to integer"
+
+    with pytest.raises(ValueError, match=msg):
+        arr.astype("uint32")
+
+
+@pytest.mark.parametrize("dropna", [True, False])
+def test_construct_index(all_data, dropna):
+    # ensure that we do not coerce to different Index dtype or non-index
+
+    all_data = all_data[:10]
+    if dropna:
+        other = np.array(all_data[~all_data.isna()])
+    else:
+        other = all_data
+
+    result = pd.Index(pd.array(other, dtype=all_data.dtype))
+    expected = pd.Index(other, dtype=all_data.dtype)
+    assert all_data.dtype == expected.dtype  # dont coerce to object
+
+    tm.assert_index_equal(result, expected)
+
+
+@pytest.mark.parametrize("dropna", [True, False])
+def test_astype_index(all_data, dropna):
+    # as an int/uint index to Index
+
+    all_data = all_data[:10]
+    if dropna:
+        other = all_data[~all_data.isna()]
+    else:
+        other = all_data
+
+    dtype = all_data.dtype
+    idx = pd.Index(np.array(other))
+    assert isinstance(idx, ABCIndex)
+
+    result = idx.astype(dtype)
+    expected = idx.astype(object).astype(dtype)
+    tm.assert_index_equal(result, expected)
+
+
+def test_astype(all_data):
+    all_data = all_data[:10]
+
+    ints = all_data[~all_data.isna()]
+    mixed = all_data
+    dtype = Int8Dtype()
+
+    # coerce to same type - ints
+    s = pd.Series(ints)
+    result = s.astype(all_data.dtype)
+    expected = pd.Series(ints)
+    tm.assert_series_equal(result, expected)
+
+    # coerce to same other - ints
+    s = pd.Series(ints)
+    result = s.astype(dtype)
+    expected = pd.Series(ints, dtype=dtype)
+    tm.assert_series_equal(result, expected)
+
+    # coerce to same numpy_dtype - ints
+    s = pd.Series(ints)
+    result = s.astype(all_data.dtype.numpy_dtype)
+    expected = pd.Series(ints._data.astype(all_data.dtype.numpy_dtype))
+    tm.assert_series_equal(result, expected)
+
+    # coerce to same type - mixed
+    s = pd.Series(mixed)
+    result = s.astype(all_data.dtype)
+    expected = pd.Series(mixed)
+    tm.assert_series_equal(result, expected)
+
+    # coerce to same other - mixed
+    s = pd.Series(mixed)
+    result = s.astype(dtype)
+    expected = pd.Series(mixed, dtype=dtype)
+    tm.assert_series_equal(result, expected)
+
+    # coerce to same numpy_dtype - mixed
+    s = pd.Series(mixed)
+    msg = "cannot convert NA to integer"
+    with pytest.raises(ValueError, match=msg):
+        s.astype(all_data.dtype.numpy_dtype)
+
+    # coerce to object
+    s = pd.Series(mixed)
+    result = s.astype("object")
+    expected = pd.Series(np.asarray(mixed, dtype=object))
+    tm.assert_series_equal(result, expected)
+
+
+def test_astype_copy():
+    arr = pd.array([1, 2, 3, None], dtype="Int64")
+    orig = pd.array([1, 2, 3, None], dtype="Int64")
+
+    # copy=True -> ensure both data and mask are actual copies
+    result = arr.astype("Int64", copy=True)
+    assert result is not arr
+    assert not tm.shares_memory(result, arr)
+    result[0] = 10
+    tm.assert_extension_array_equal(arr, orig)
+    result[0] = pd.NA
+    tm.assert_extension_array_equal(arr, orig)
+
+    # copy=False
+    result = arr.astype("Int64", copy=False)
+    assert result is arr
+    assert np.shares_memory(result._data, arr._data)
+    assert np.shares_memory(result._mask, arr._mask)
+    result[0] = 10
+    assert arr[0] == 10
+    result[0] = pd.NA
+    assert arr[0] is pd.NA
+
+    # astype to different dtype -> always needs a copy -> even with copy=False
+    # we need to ensure that also the mask is actually copied
+    arr = pd.array([1, 2, 3, None], dtype="Int64")
+    orig = pd.array([1, 2, 3, None], dtype="Int64")
+
+    result = arr.astype("Int32", copy=False)
+    assert not tm.shares_memory(result, arr)
+    result[0] = 10
+    tm.assert_extension_array_equal(arr, orig)
+    result[0] = pd.NA
+    tm.assert_extension_array_equal(arr, orig)
+
+
+def test_astype_to_larger_numpy():
+    a = pd.array([1, 2], dtype="Int32")
+    result = a.astype("int64")
+    expected = np.array([1, 2], dtype="int64")
+    tm.assert_numpy_array_equal(result, expected)
+
+    a = pd.array([1, 2], dtype="UInt32")
+    result = a.astype("uint64")
+    expected = np.array([1, 2], dtype="uint64")
+    tm.assert_numpy_array_equal(result, expected)
+
+
+@pytest.mark.parametrize("dtype", [Int8Dtype(), "Int8", UInt32Dtype(), "UInt32"])
+def test_astype_specific_casting(dtype):
+    s = pd.Series([1, 2, 3], dtype="Int64")
+    result = s.astype(dtype)
+    expected = pd.Series([1, 2, 3], dtype=dtype)
+    tm.assert_series_equal(result, expected)
+
+    s = pd.Series([1, 2, 3, None], dtype="Int64")
+    result = s.astype(dtype)
+    expected = pd.Series([1, 2, 3, None], dtype=dtype)
+    tm.assert_series_equal(result, expected)
+
+
+def test_astype_floating():
+    arr = pd.array([1, 2, None], dtype="Int64")
+    result = arr.astype("Float64")
+    expected = pd.array([1.0, 2.0, None], dtype="Float64")
+    tm.assert_extension_array_equal(result, expected)
+
+
+def test_astype_dt64():
+    # GH#32435
+    arr = pd.array([1, 2, 3, pd.NA]) * 10**9
+
+    result = arr.astype("datetime64[ns]")
+
+    expected = np.array([1, 2, 3, "NaT"], dtype="M8[s]").astype("M8[ns]")
+    tm.assert_numpy_array_equal(result, expected)
+
+
+def test_construct_cast_invalid(dtype):
+    msg = "cannot safely"
+    arr = [1.2, 2.3, 3.7]
+    with pytest.raises(TypeError, match=msg):
+        pd.array(arr, dtype=dtype)
+
+    with pytest.raises(TypeError, match=msg):
+        pd.Series(arr).astype(dtype)
+
+    arr = [1.2, 2.3, 3.7, np.nan]
+    with pytest.raises(TypeError, match=msg):
+        pd.array(arr, dtype=dtype)
+
+    with pytest.raises(TypeError, match=msg):
+        pd.Series(arr).astype(dtype)
+
+
+@pytest.mark.parametrize("in_series", [True, False])
+def test_to_numpy_na_nan(in_series):
+    a = pd.array([0, 1, None], dtype="Int64")
+    if in_series:
+        a = pd.Series(a)
+
+    result = a.to_numpy(dtype="float64", na_value=np.nan)
+    expected = np.array([0.0, 1.0, np.nan], dtype="float64")
+    tm.assert_numpy_array_equal(result, expected)
+
+    result = a.to_numpy(dtype="int64", na_value=-1)
+    expected = np.array([0, 1, -1], dtype="int64")
+    tm.assert_numpy_array_equal(result, expected)
+
+    result = a.to_numpy(dtype="bool", na_value=False)
+    expected = np.array([False, True, False], dtype="bool")
+    tm.assert_numpy_array_equal(result, expected)
+
+
+@pytest.mark.parametrize("in_series", [True, False])
+@pytest.mark.parametrize("dtype", ["int32", "int64", "bool"])
+def test_to_numpy_dtype(dtype, in_series):
+    a = pd.array([0, 1], dtype="Int64")
+    if in_series:
+        a = pd.Series(a)
+
+    result = a.to_numpy(dtype=dtype)
+    expected = np.array([0, 1], dtype=dtype)
+    tm.assert_numpy_array_equal(result, expected)
+
+
+@pytest.mark.parametrize("dtype", ["int64", "bool"])
+def test_to_numpy_na_raises(dtype):
+    a = pd.array([0, 1, None], dtype="Int64")
+    with pytest.raises(ValueError, match=dtype):
+        a.to_numpy(dtype=dtype)
+
+
+def test_astype_str():
+    a = pd.array([1, 2, None], dtype="Int64")
+    expected = np.array(["1", "2", "<NA>"], dtype=f"{tm.ENDIAN}U21")
+
+    tm.assert_numpy_array_equal(a.astype(str), expected)
+    tm.assert_numpy_array_equal(a.astype("str"), expected)
+
+
+def test_astype_boolean():
+    # https://github.com/pandas-dev/pandas/issues/31102
+    a = pd.array([1, 0, -1, 2, None], dtype="Int64")
+    result = a.astype("boolean")
+    expected = pd.array([True, False, True, True, None], dtype="boolean")
+    tm.assert_extension_array_equal(result, expected)

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

@@ -0,0 +1,203 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+from pandas.core.arrays import FloatingArray
+
+
+@pytest.mark.parametrize("ufunc", [np.abs, np.sign])
+# np.sign emits a warning with nans, <https://github.com/numpy/numpy/issues/15127>
+@pytest.mark.filterwarnings("ignore:invalid value encountered in sign:RuntimeWarning")
+def test_ufuncs_single_int(ufunc):
+    a = pd.array([1, 2, -3, np.nan])
+    result = ufunc(a)
+    expected = pd.array(ufunc(a.astype(float)), dtype="Int64")
+    tm.assert_extension_array_equal(result, expected)
+
+    s = pd.Series(a)
+    result = ufunc(s)
+    expected = pd.Series(pd.array(ufunc(a.astype(float)), dtype="Int64"))
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("ufunc", [np.log, np.exp, np.sin, np.cos, np.sqrt])
+def test_ufuncs_single_float(ufunc):
+    a = pd.array([1, 2, -3, np.nan])
+    with np.errstate(invalid="ignore"):
+        result = ufunc(a)
+        expected = FloatingArray(ufunc(a.astype(float)), mask=a._mask)
+    tm.assert_extension_array_equal(result, expected)
+
+    s = pd.Series(a)
+    with np.errstate(invalid="ignore"):
+        result = ufunc(s)
+    expected = pd.Series(expected)
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("ufunc", [np.add, np.subtract])
+def test_ufuncs_binary_int(ufunc):
+    # two IntegerArrays
+    a = pd.array([1, 2, -3, np.nan])
+    result = ufunc(a, a)
+    expected = pd.array(ufunc(a.astype(float), a.astype(float)), dtype="Int64")
+    tm.assert_extension_array_equal(result, expected)
+
+    # IntegerArray with numpy array
+    arr = np.array([1, 2, 3, 4])
+    result = ufunc(a, arr)
+    expected = pd.array(ufunc(a.astype(float), arr), dtype="Int64")
+    tm.assert_extension_array_equal(result, expected)
+
+    result = ufunc(arr, a)
+    expected = pd.array(ufunc(arr, a.astype(float)), dtype="Int64")
+    tm.assert_extension_array_equal(result, expected)
+
+    # IntegerArray with scalar
+    result = ufunc(a, 1)
+    expected = pd.array(ufunc(a.astype(float), 1), dtype="Int64")
+    tm.assert_extension_array_equal(result, expected)
+
+    result = ufunc(1, a)
+    expected = pd.array(ufunc(1, a.astype(float)), dtype="Int64")
+    tm.assert_extension_array_equal(result, expected)
+
+
+def test_ufunc_binary_output():
+    a = pd.array([1, 2, np.nan])
+    result = np.modf(a)
+    expected = np.modf(a.to_numpy(na_value=np.nan, dtype="float"))
+    expected = (pd.array(expected[0]), pd.array(expected[1]))
+
+    assert isinstance(result, tuple)
+    assert len(result) == 2
+
+    for x, y in zip(result, expected):
+        tm.assert_extension_array_equal(x, y)
+
+
+@pytest.mark.parametrize("values", [[0, 1], [0, None]])
+def test_ufunc_reduce_raises(values):
+    arr = pd.array(values)
+
+    res = np.add.reduce(arr)
+    expected = arr.sum(skipna=False)
+    tm.assert_almost_equal(res, expected)
+
+
+@pytest.mark.parametrize(
+    "pandasmethname, kwargs",
+    [
+        ("var", {"ddof": 0}),
+        ("var", {"ddof": 1}),
+        ("std", {"ddof": 0}),
+        ("std", {"ddof": 1}),
+        ("kurtosis", {}),
+        ("skew", {}),
+        ("sem", {}),
+    ],
+)
+def test_stat_method(pandasmethname, kwargs):
+    s = pd.Series(data=[1, 2, 3, 4, 5, 6, np.nan, np.nan], dtype="Int64")
+    pandasmeth = getattr(s, pandasmethname)
+    result = pandasmeth(**kwargs)
+    s2 = pd.Series(data=[1, 2, 3, 4, 5, 6], dtype="Int64")
+    pandasmeth = getattr(s2, pandasmethname)
+    expected = pandasmeth(**kwargs)
+    assert expected == result
+
+
+def test_value_counts_na():
+    arr = pd.array([1, 2, 1, pd.NA], dtype="Int64")
+    result = arr.value_counts(dropna=False)
+    ex_index = pd.Index([1, 2, pd.NA], dtype="Int64")
+    assert ex_index.dtype == "Int64"
+    expected = pd.Series([2, 1, 1], index=ex_index, dtype="Int64", name="count")
+    tm.assert_series_equal(result, expected)
+
+    result = arr.value_counts(dropna=True)
+    expected = pd.Series([2, 1], index=arr[:2], dtype="Int64", name="count")
+    assert expected.index.dtype == arr.dtype
+    tm.assert_series_equal(result, expected)
+
+
+def test_value_counts_empty():
+    # https://github.com/pandas-dev/pandas/issues/33317
+    ser = pd.Series([], dtype="Int64")
+    result = ser.value_counts()
+    idx = pd.Index([], dtype=ser.dtype)
+    assert idx.dtype == ser.dtype
+    expected = pd.Series([], index=idx, dtype="Int64", name="count")
+    tm.assert_series_equal(result, expected)
+
+
+def test_value_counts_with_normalize():
+    # GH 33172
+    ser = pd.Series([1, 2, 1, pd.NA], dtype="Int64")
+    result = ser.value_counts(normalize=True)
+    expected = pd.Series([2, 1], index=ser[:2], dtype="Float64", name="proportion") / 3
+    assert expected.index.dtype == ser.dtype
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("skipna", [True, False])
+@pytest.mark.parametrize("min_count", [0, 4])
+def test_integer_array_sum(skipna, min_count, any_int_ea_dtype):
+    dtype = any_int_ea_dtype
+    arr = pd.array([1, 2, 3, None], dtype=dtype)
+    result = arr.sum(skipna=skipna, min_count=min_count)
+    if skipna and min_count == 0:
+        assert result == 6
+    else:
+        assert result is pd.NA
+
+
+@pytest.mark.parametrize("skipna", [True, False])
+@pytest.mark.parametrize("method", ["min", "max"])
+def test_integer_array_min_max(skipna, method, any_int_ea_dtype):
+    dtype = any_int_ea_dtype
+    arr = pd.array([0, 1, None], dtype=dtype)
+    func = getattr(arr, method)
+    result = func(skipna=skipna)
+    if skipna:
+        assert result == (0 if method == "min" else 1)
+    else:
+        assert result is pd.NA
+
+
+@pytest.mark.parametrize("skipna", [True, False])
+@pytest.mark.parametrize("min_count", [0, 9])
+def test_integer_array_prod(skipna, min_count, any_int_ea_dtype):
+    dtype = any_int_ea_dtype
+    arr = pd.array([1, 2, None], dtype=dtype)
+    result = arr.prod(skipna=skipna, min_count=min_count)
+    if skipna and min_count == 0:
+        assert result == 2
+    else:
+        assert result is pd.NA
+
+
+@pytest.mark.parametrize(
+    "values, expected", [([1, 2, 3], 6), ([1, 2, 3, None], 6), ([None], 0)]
+)
+def test_integer_array_numpy_sum(values, expected):
+    arr = pd.array(values, dtype="Int64")
+    result = np.sum(arr)
+    assert result == expected
+
+
+@pytest.mark.parametrize("op", ["sum", "prod", "min", "max"])
+def test_dataframe_reductions(op):
+    # https://github.com/pandas-dev/pandas/pull/32867
+    # ensure the integers are not cast to float during reductions
+    df = pd.DataFrame({"a": pd.array([1, 2], dtype="Int64")})
+    result = df.max()
+    assert isinstance(result["a"], np.int64)
+
+
+# TODO(jreback) - these need testing / are broken
+
+# shift
+
+# set_index (destroys type)

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

@@ -0,0 +1,125 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    Series,
+    array,
+)
+import pandas._testing as tm
+
+
+@pytest.mark.parametrize(
+    "op, expected",
+    [
+        ["sum", np.int64(3)],
+        ["prod", np.int64(2)],
+        ["min", np.int64(1)],
+        ["max", np.int64(2)],
+        ["mean", np.float64(1.5)],
+        ["median", np.float64(1.5)],
+        ["var", np.float64(0.5)],
+        ["std", np.float64(0.5**0.5)],
+        ["skew", pd.NA],
+        ["kurt", pd.NA],
+        ["any", True],
+        ["all", True],
+    ],
+)
+def test_series_reductions(op, expected):
+    ser = Series([1, 2], dtype="Int64")
+    result = getattr(ser, op)()
+    tm.assert_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "op, expected",
+    [
+        ["sum", Series([3], index=["a"], dtype="Int64")],
+        ["prod", Series([2], index=["a"], dtype="Int64")],
+        ["min", Series([1], index=["a"], dtype="Int64")],
+        ["max", Series([2], index=["a"], dtype="Int64")],
+        ["mean", Series([1.5], index=["a"], dtype="Float64")],
+        ["median", Series([1.5], index=["a"], dtype="Float64")],
+        ["var", Series([0.5], index=["a"], dtype="Float64")],
+        ["std", Series([0.5**0.5], index=["a"], dtype="Float64")],
+        ["skew", Series([pd.NA], index=["a"], dtype="Float64")],
+        ["kurt", Series([pd.NA], index=["a"], dtype="Float64")],
+        ["any", Series([True], index=["a"], dtype="boolean")],
+        ["all", Series([True], index=["a"], dtype="boolean")],
+    ],
+)
+def test_dataframe_reductions(op, expected):
+    df = DataFrame({"a": array([1, 2], dtype="Int64")})
+    result = getattr(df, op)()
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "op, expected",
+    [
+        ["sum", array([1, 3], dtype="Int64")],
+        ["prod", array([1, 3], dtype="Int64")],
+        ["min", array([1, 3], dtype="Int64")],
+        ["max", array([1, 3], dtype="Int64")],
+        ["mean", array([1, 3], dtype="Float64")],
+        ["median", array([1, 3], dtype="Float64")],
+        ["var", array([pd.NA], dtype="Float64")],
+        ["std", array([pd.NA], dtype="Float64")],
+        ["skew", array([pd.NA], dtype="Float64")],
+        ["any", array([True, True], dtype="boolean")],
+        ["all", array([True, True], dtype="boolean")],
+    ],
+)
+def test_groupby_reductions(op, expected):
+    df = DataFrame(
+        {
+            "A": ["a", "b", "b"],
+            "B": array([1, None, 3], dtype="Int64"),
+        }
+    )
+    result = getattr(df.groupby("A"), op)()
+    expected = DataFrame(expected, index=pd.Index(["a", "b"], name="A"), columns=["B"])
+
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "op, expected",
+    [
+        ["sum", Series([4, 4], index=["B", "C"], dtype="Float64")],
+        ["prod", Series([3, 3], index=["B", "C"], dtype="Float64")],
+        ["min", Series([1, 1], index=["B", "C"], dtype="Float64")],
+        ["max", Series([3, 3], index=["B", "C"], dtype="Float64")],
+        ["mean", Series([2, 2], index=["B", "C"], dtype="Float64")],
+        ["median", Series([2, 2], index=["B", "C"], dtype="Float64")],
+        ["var", Series([2, 2], index=["B", "C"], dtype="Float64")],
+        ["std", Series([2**0.5, 2**0.5], index=["B", "C"], dtype="Float64")],
+        ["skew", Series([pd.NA, pd.NA], index=["B", "C"], dtype="Float64")],
+        ["kurt", Series([pd.NA, pd.NA], index=["B", "C"], dtype="Float64")],
+        ["any", Series([True, True, True], index=["A", "B", "C"], dtype="boolean")],
+        ["all", Series([True, True, True], index=["A", "B", "C"], dtype="boolean")],
+    ],
+)
+def test_mixed_reductions(op, expected, using_infer_string):
+    if op in ["any", "all"] and using_infer_string:
+        expected = expected.astype("bool")
+    df = DataFrame(
+        {
+            "A": ["a", "b", "b"],
+            "B": [1, None, 3],
+            "C": array([1, None, 3], dtype="Int64"),
+        }
+    )
+
+    # series
+    result = getattr(df.C, op)()
+    tm.assert_equal(result, expected["C"])
+
+    # frame
+    if op in ["any", "all"]:
+        result = getattr(df, op)()
+    else:
+        result = getattr(df, op)(numeric_only=True)
+    tm.assert_series_equal(result, expected)

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

@@ -0,0 +1,67 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas.core.arrays.integer import (
+    Int8Dtype,
+    Int16Dtype,
+    Int32Dtype,
+    Int64Dtype,
+    UInt8Dtype,
+    UInt16Dtype,
+    UInt32Dtype,
+    UInt64Dtype,
+)
+
+
+def test_dtypes(dtype):
+    # smoke tests on auto dtype construction
+
+    if dtype.is_signed_integer:
+        assert np.dtype(dtype.type).kind == "i"
+    else:
+        assert np.dtype(dtype.type).kind == "u"
+    assert dtype.name is not None
+
+
+@pytest.mark.parametrize(
+    "dtype, expected",
+    [
+        (Int8Dtype(), "Int8Dtype()"),
+        (Int16Dtype(), "Int16Dtype()"),
+        (Int32Dtype(), "Int32Dtype()"),
+        (Int64Dtype(), "Int64Dtype()"),
+        (UInt8Dtype(), "UInt8Dtype()"),
+        (UInt16Dtype(), "UInt16Dtype()"),
+        (UInt32Dtype(), "UInt32Dtype()"),
+        (UInt64Dtype(), "UInt64Dtype()"),
+    ],
+)
+def test_repr_dtype(dtype, expected):
+    assert repr(dtype) == expected
+
+
+def test_repr_array():
+    result = repr(pd.array([1, None, 3]))
+    expected = "<IntegerArray>\n[1, <NA>, 3]\nLength: 3, dtype: Int64"
+    assert result == expected
+
+
+def test_repr_array_long():
+    data = pd.array([1, 2, None] * 1000)
+    expected = (
+        "<IntegerArray>\n"
+        "[   1,    2, <NA>,    1,    2, <NA>,    1,    2, <NA>,    1,\n"
+        " ...\n"
+        " <NA>,    1,    2, <NA>,    1,    2, <NA>,    1,    2, <NA>]\n"
+        "Length: 3000, dtype: Int64"
+    )
+    result = repr(data)
+    assert result == expected
+
+
+def test_frame_repr(data_missing):
+    df = pd.DataFrame({"A": data_missing})
+    result = repr(df)
+    expected = "      A\n0  <NA>\n1     1"
+    assert result == expected

venv/lib/python3.10/site-packages/pandas/tests/io/json/test_compression.py

@@ -0,0 +1,130 @@
+from io import (
+    BytesIO,
+    StringIO,
+)
+
+import pytest
+
+import pandas.util._test_decorators as td
+
+import pandas as pd
+import pandas._testing as tm
+
+
+def test_compression_roundtrip(compression):
+    df = pd.DataFrame(
+        [[0.123456, 0.234567, 0.567567], [12.32112, 123123.2, 321321.2]],
+        index=["A", "B"],
+        columns=["X", "Y", "Z"],
+    )
+
+    with tm.ensure_clean() as path:
+        df.to_json(path, compression=compression)
+        tm.assert_frame_equal(df, pd.read_json(path, compression=compression))
+
+        # explicitly ensure file was compressed.
+        with tm.decompress_file(path, compression) as fh:
+            result = fh.read().decode("utf8")
+            data = StringIO(result)
+        tm.assert_frame_equal(df, pd.read_json(data))
+
+
+def test_read_zipped_json(datapath):
+    uncompressed_path = datapath("io", "json", "data", "tsframe_v012.json")
+    uncompressed_df = pd.read_json(uncompressed_path)
+
+    compressed_path = datapath("io", "json", "data", "tsframe_v012.json.zip")
+    compressed_df = pd.read_json(compressed_path, compression="zip")
+
+    tm.assert_frame_equal(uncompressed_df, compressed_df)
+
+
+@td.skip_if_not_us_locale
+@pytest.mark.single_cpu
+def test_with_s3_url(compression, s3_public_bucket, s3so):
+    # Bucket created in tests/io/conftest.py
+    df = pd.read_json(StringIO('{"a": [1, 2, 3], "b": [4, 5, 6]}'))
+
+    with tm.ensure_clean() as path:
+        df.to_json(path, compression=compression)
+        with open(path, "rb") as f:
+            s3_public_bucket.put_object(Key="test-1", Body=f)
+
+    roundtripped_df = pd.read_json(
+        f"s3://{s3_public_bucket.name}/test-1",
+        compression=compression,
+        storage_options=s3so,
+    )
+    tm.assert_frame_equal(df, roundtripped_df)
+
+
+def test_lines_with_compression(compression):
+    with tm.ensure_clean() as path:
+        df = pd.read_json(StringIO('{"a": [1, 2, 3], "b": [4, 5, 6]}'))
+        df.to_json(path, orient="records", lines=True, compression=compression)
+        roundtripped_df = pd.read_json(path, lines=True, compression=compression)
+        tm.assert_frame_equal(df, roundtripped_df)
+
+
+def test_chunksize_with_compression(compression):
+    with tm.ensure_clean() as path:
+        df = pd.read_json(StringIO('{"a": ["foo", "bar", "baz"], "b": [4, 5, 6]}'))
+        df.to_json(path, orient="records", lines=True, compression=compression)
+
+        with pd.read_json(
+            path, lines=True, chunksize=1, compression=compression
+        ) as res:
+            roundtripped_df = pd.concat(res)
+        tm.assert_frame_equal(df, roundtripped_df)
+
+
+def test_write_unsupported_compression_type():
+    df = pd.read_json(StringIO('{"a": [1, 2, 3], "b": [4, 5, 6]}'))
+    with tm.ensure_clean() as path:
+        msg = "Unrecognized compression type: unsupported"
+        with pytest.raises(ValueError, match=msg):
+            df.to_json(path, compression="unsupported")
+
+
+def test_read_unsupported_compression_type():
+    with tm.ensure_clean() as path:
+        msg = "Unrecognized compression type: unsupported"
+        with pytest.raises(ValueError, match=msg):
+            pd.read_json(path, compression="unsupported")
+
+
+@pytest.mark.parametrize(
+    "infer_string", [False, pytest.param(True, marks=td.skip_if_no("pyarrow"))]
+)
+@pytest.mark.parametrize("to_infer", [True, False])
+@pytest.mark.parametrize("read_infer", [True, False])
+def test_to_json_compression(
+    compression_only, read_infer, to_infer, compression_to_extension, infer_string
+):
+    with pd.option_context("future.infer_string", infer_string):
+        # see gh-15008
+        compression = compression_only
+
+        # We'll complete file extension subsequently.
+        filename = "test."
+        filename += compression_to_extension[compression]
+
+        df = pd.DataFrame({"A": [1]})
+
+        to_compression = "infer" if to_infer else compression
+        read_compression = "infer" if read_infer else compression
+
+        with tm.ensure_clean(filename) as path:
+            df.to_json(path, compression=to_compression)
+            result = pd.read_json(path, compression=read_compression)
+            tm.assert_frame_equal(result, df)
+
+
+def test_to_json_compression_mode(compression):
+    # GH 39985 (read_json does not support user-provided binary files)
+    expected = pd.DataFrame({"A": [1]})
+
+    with BytesIO() as buffer:
+        expected.to_json(buffer, compression=compression)
+        # df = pd.read_json(buffer, compression=compression)
+        # tm.assert_frame_equal(expected, df)

venv/lib/python3.10/site-packages/pandas/tests/io/json/test_deprecated_kwargs.py

@@ -0,0 +1,21 @@
+"""
+Tests for the deprecated keyword arguments for `read_json`.
+"""
+from io import StringIO
+
+import pandas as pd
+import pandas._testing as tm
+
+from pandas.io.json import read_json
+
+
+def test_good_kwargs():
+    df = pd.DataFrame({"A": [2, 4, 6], "B": [3, 6, 9]}, index=[0, 1, 2])
+
+    with tm.assert_produces_warning(None):
+        data1 = StringIO(df.to_json(orient="split"))
+        tm.assert_frame_equal(df, read_json(data1, orient="split"))
+        data2 = StringIO(df.to_json(orient="columns"))
+        tm.assert_frame_equal(df, read_json(data2, orient="columns"))
+        data3 = StringIO(df.to_json(orient="index"))
+        tm.assert_frame_equal(df, read_json(data3, orient="index"))

venv/lib/python3.10/site-packages/pandas/tests/io/json/test_json_table_schema.py

@@ -0,0 +1,873 @@
+"""Tests for Table Schema integration."""
+from collections import OrderedDict
+from io import StringIO
+import json
+
+import numpy as np
+import pytest
+
+from pandas.core.dtypes.dtypes import (
+    CategoricalDtype,
+    DatetimeTZDtype,
+    PeriodDtype,
+)
+
+import pandas as pd
+from pandas import DataFrame
+import pandas._testing as tm
+
+from pandas.io.json._table_schema import (
+    as_json_table_type,
+    build_table_schema,
+    convert_json_field_to_pandas_type,
+    convert_pandas_type_to_json_field,
+    set_default_names,
+)
+
+
+@pytest.fixture
+def df_schema():
+    return DataFrame(
+        {
+            "A": [1, 2, 3, 4],
+            "B": ["a", "b", "c", "c"],
+            "C": pd.date_range("2016-01-01", freq="d", periods=4),
+            "D": pd.timedelta_range("1h", periods=4, freq="min"),
+        },
+        index=pd.Index(range(4), name="idx"),
+    )
+
+
+@pytest.fixture
+def df_table():
+    return DataFrame(
+        {
+            "A": [1, 2, 3, 4],
+            "B": ["a", "b", "c", "c"],
+            "C": pd.date_range("2016-01-01", freq="d", periods=4),
+            "D": pd.timedelta_range("1h", periods=4, freq="min"),
+            "E": pd.Series(pd.Categorical(["a", "b", "c", "c"])),
+            "F": pd.Series(pd.Categorical(["a", "b", "c", "c"], ordered=True)),
+            "G": [1.0, 2.0, 3, 4.0],
+            "H": pd.date_range("2016-01-01", freq="d", periods=4, tz="US/Central"),
+        },
+        index=pd.Index(range(4), name="idx"),
+    )
+
+
+class TestBuildSchema:
+    def test_build_table_schema(self, df_schema, using_infer_string):
+        result = build_table_schema(df_schema, version=False)
+        expected = {
+            "fields": [
+                {"name": "idx", "type": "integer"},
+                {"name": "A", "type": "integer"},
+                {"name": "B", "type": "string"},
+                {"name": "C", "type": "datetime"},
+                {"name": "D", "type": "duration"},
+            ],
+            "primaryKey": ["idx"],
+        }
+        if using_infer_string:
+            expected["fields"][2] = {"name": "B", "type": "any", "extDtype": "string"}
+        assert result == expected
+        result = build_table_schema(df_schema)
+        assert "pandas_version" in result
+
+    def test_series(self):
+        s = pd.Series([1, 2, 3], name="foo")
+        result = build_table_schema(s, version=False)
+        expected = {
+            "fields": [
+                {"name": "index", "type": "integer"},
+                {"name": "foo", "type": "integer"},
+            ],
+            "primaryKey": ["index"],
+        }
+        assert result == expected
+        result = build_table_schema(s)
+        assert "pandas_version" in result
+
+    def test_series_unnamed(self):
+        result = build_table_schema(pd.Series([1, 2, 3]), version=False)
+        expected = {
+            "fields": [
+                {"name": "index", "type": "integer"},
+                {"name": "values", "type": "integer"},
+            ],
+            "primaryKey": ["index"],
+        }
+        assert result == expected
+
+    def test_multiindex(self, df_schema, using_infer_string):
+        df = df_schema
+        idx = pd.MultiIndex.from_product([("a", "b"), (1, 2)])
+        df.index = idx
+
+        result = build_table_schema(df, version=False)
+        expected = {
+            "fields": [
+                {"name": "level_0", "type": "string"},
+                {"name": "level_1", "type": "integer"},
+                {"name": "A", "type": "integer"},
+                {"name": "B", "type": "string"},
+                {"name": "C", "type": "datetime"},
+                {"name": "D", "type": "duration"},
+            ],
+            "primaryKey": ["level_0", "level_1"],
+        }
+        if using_infer_string:
+            expected["fields"][0] = {
+                "name": "level_0",
+                "type": "any",
+                "extDtype": "string",
+            }
+            expected["fields"][3] = {"name": "B", "type": "any", "extDtype": "string"}
+        assert result == expected
+
+        df.index.names = ["idx0", None]
+        expected["fields"][0]["name"] = "idx0"
+        expected["primaryKey"] = ["idx0", "level_1"]
+        result = build_table_schema(df, version=False)
+        assert result == expected
+
+
+class TestTableSchemaType:
+    @pytest.mark.parametrize("int_type", [int, np.int16, np.int32, np.int64])
+    def test_as_json_table_type_int_data(self, int_type):
+        int_data = [1, 2, 3]
+        assert as_json_table_type(np.array(int_data, dtype=int_type).dtype) == "integer"
+
+    @pytest.mark.parametrize("float_type", [float, np.float16, np.float32, np.float64])
+    def test_as_json_table_type_float_data(self, float_type):
+        float_data = [1.0, 2.0, 3.0]
+        assert (
+            as_json_table_type(np.array(float_data, dtype=float_type).dtype) == "number"
+        )
+
+    @pytest.mark.parametrize("bool_type", [bool, np.bool_])
+    def test_as_json_table_type_bool_data(self, bool_type):
+        bool_data = [True, False]
+        assert (
+            as_json_table_type(np.array(bool_data, dtype=bool_type).dtype) == "boolean"
+        )
+
+    @pytest.mark.parametrize(
+        "date_data",
+        [
+            pd.to_datetime(["2016"]),
+            pd.to_datetime(["2016"], utc=True),
+            pd.Series(pd.to_datetime(["2016"])),
+            pd.Series(pd.to_datetime(["2016"], utc=True)),
+            pd.period_range("2016", freq="Y", periods=3),
+        ],
+    )
+    def test_as_json_table_type_date_data(self, date_data):
+        assert as_json_table_type(date_data.dtype) == "datetime"
+
+    @pytest.mark.parametrize(
+        "str_data",
+        [pd.Series(["a", "b"], dtype=object), pd.Index(["a", "b"], dtype=object)],
+    )
+    def test_as_json_table_type_string_data(self, str_data):
+        assert as_json_table_type(str_data.dtype) == "string"
+
+    @pytest.mark.parametrize(
+        "cat_data",
+        [
+            pd.Categorical(["a"]),
+            pd.Categorical([1]),
+            pd.Series(pd.Categorical([1])),
+            pd.CategoricalIndex([1]),
+            pd.Categorical([1]),
+        ],
+    )
+    def test_as_json_table_type_categorical_data(self, cat_data):
+        assert as_json_table_type(cat_data.dtype) == "any"
+
+    # ------
+    # dtypes
+    # ------
+    @pytest.mark.parametrize("int_dtype", [int, np.int16, np.int32, np.int64])
+    def test_as_json_table_type_int_dtypes(self, int_dtype):
+        assert as_json_table_type(int_dtype) == "integer"
+
+    @pytest.mark.parametrize("float_dtype", [float, np.float16, np.float32, np.float64])
+    def test_as_json_table_type_float_dtypes(self, float_dtype):
+        assert as_json_table_type(float_dtype) == "number"
+
+    @pytest.mark.parametrize("bool_dtype", [bool, np.bool_])
+    def test_as_json_table_type_bool_dtypes(self, bool_dtype):
+        assert as_json_table_type(bool_dtype) == "boolean"
+
+    @pytest.mark.parametrize(
+        "date_dtype",
+        [
+            np.dtype("<M8[ns]"),
+            PeriodDtype("D"),
+            DatetimeTZDtype("ns", "US/Central"),
+        ],
+    )
+    def test_as_json_table_type_date_dtypes(self, date_dtype):
+        # TODO: datedate.date? datetime.time?
+        assert as_json_table_type(date_dtype) == "datetime"
+
+    @pytest.mark.parametrize("td_dtype", [np.dtype("<m8[ns]")])
+    def test_as_json_table_type_timedelta_dtypes(self, td_dtype):
+        assert as_json_table_type(td_dtype) == "duration"
+
+    @pytest.mark.parametrize("str_dtype", [object])  # TODO(GH#14904) flesh out dtypes?
+    def test_as_json_table_type_string_dtypes(self, str_dtype):
+        assert as_json_table_type(str_dtype) == "string"
+
+    def test_as_json_table_type_categorical_dtypes(self):
+        assert as_json_table_type(pd.Categorical(["a"]).dtype) == "any"
+        assert as_json_table_type(CategoricalDtype()) == "any"
+
+
+class TestTableOrient:
+    def test_build_series(self):
+        s = pd.Series([1, 2], name="a")
+        s.index.name = "id"
+        result = s.to_json(orient="table", date_format="iso")
+        result = json.loads(result, object_pairs_hook=OrderedDict)
+
+        assert "pandas_version" in result["schema"]
+        result["schema"].pop("pandas_version")
+
+        fields = [{"name": "id", "type": "integer"}, {"name": "a", "type": "integer"}]
+
+        schema = {"fields": fields, "primaryKey": ["id"]}
+
+        expected = OrderedDict(
+            [
+                ("schema", schema),
+                (
+                    "data",
+                    [
+                        OrderedDict([("id", 0), ("a", 1)]),
+                        OrderedDict([("id", 1), ("a", 2)]),
+                    ],
+                ),
+            ]
+        )
+
+        assert result == expected
+
+    def test_read_json_from_to_json_results(self):
+        # GH32383
+        df = DataFrame(
+            {
+                "_id": {"row_0": 0},
+                "category": {"row_0": "Goods"},
+                "recommender_id": {"row_0": 3},
+                "recommender_name_jp": {"row_0": "浦田"},
+                "recommender_name_en": {"row_0": "Urata"},
+                "name_jp": {"row_0": "博多人形(松尾吉将まつお よしまさ)"},
+                "name_en": {"row_0": "Hakata Dolls Matsuo"},
+            }
+        )
+
+        result1 = pd.read_json(StringIO(df.to_json()))
+        result2 = DataFrame.from_dict(json.loads(df.to_json()))
+        tm.assert_frame_equal(result1, df)
+        tm.assert_frame_equal(result2, df)
+
+    def test_to_json(self, df_table, using_infer_string):
+        df = df_table
+        df.index.name = "idx"
+        result = df.to_json(orient="table", date_format="iso")
+        result = json.loads(result, object_pairs_hook=OrderedDict)
+
+        assert "pandas_version" in result["schema"]
+        result["schema"].pop("pandas_version")
+
+        fields = [
+            {"name": "idx", "type": "integer"},
+            {"name": "A", "type": "integer"},
+            {"name": "B", "type": "string"},
+            {"name": "C", "type": "datetime"},
+            {"name": "D", "type": "duration"},
+            {
+                "constraints": {"enum": ["a", "b", "c"]},
+                "name": "E",
+                "ordered": False,
+                "type": "any",
+            },
+            {
+                "constraints": {"enum": ["a", "b", "c"]},
+                "name": "F",
+                "ordered": True,
+                "type": "any",
+            },
+            {"name": "G", "type": "number"},
+            {"name": "H", "type": "datetime", "tz": "US/Central"},
+        ]
+
+        if using_infer_string:
+            fields[2] = {"name": "B", "type": "any", "extDtype": "string"}
+
+        schema = {"fields": fields, "primaryKey": ["idx"]}
+        data = [
+            OrderedDict(
+                [
+                    ("idx", 0),
+                    ("A", 1),
+                    ("B", "a"),
+                    ("C", "2016-01-01T00:00:00.000"),
+                    ("D", "P0DT1H0M0S"),
+                    ("E", "a"),
+                    ("F", "a"),
+                    ("G", 1.0),
+                    ("H", "2016-01-01T06:00:00.000Z"),
+                ]
+            ),
+            OrderedDict(
+                [
+                    ("idx", 1),
+                    ("A", 2),
+                    ("B", "b"),
+                    ("C", "2016-01-02T00:00:00.000"),
+                    ("D", "P0DT1H1M0S"),
+                    ("E", "b"),
+                    ("F", "b"),
+                    ("G", 2.0),
+                    ("H", "2016-01-02T06:00:00.000Z"),
+                ]
+            ),
+            OrderedDict(
+                [
+                    ("idx", 2),
+                    ("A", 3),
+                    ("B", "c"),
+                    ("C", "2016-01-03T00:00:00.000"),
+                    ("D", "P0DT1H2M0S"),
+                    ("E", "c"),
+                    ("F", "c"),
+                    ("G", 3.0),
+                    ("H", "2016-01-03T06:00:00.000Z"),
+                ]
+            ),
+            OrderedDict(
+                [
+                    ("idx", 3),
+                    ("A", 4),
+                    ("B", "c"),
+                    ("C", "2016-01-04T00:00:00.000"),
+                    ("D", "P0DT1H3M0S"),
+                    ("E", "c"),
+                    ("F", "c"),
+                    ("G", 4.0),
+                    ("H", "2016-01-04T06:00:00.000Z"),
+                ]
+            ),
+        ]
+        expected = OrderedDict([("schema", schema), ("data", data)])
+
+        assert result == expected
+
+    def test_to_json_float_index(self):
+        data = pd.Series(1, index=[1.0, 2.0])
+        result = data.to_json(orient="table", date_format="iso")
+        result = json.loads(result, object_pairs_hook=OrderedDict)
+        result["schema"].pop("pandas_version")
+
+        expected = OrderedDict(
+            [
+                (
+                    "schema",
+                    {
+                        "fields": [
+                            {"name": "index", "type": "number"},
+                            {"name": "values", "type": "integer"},
+                        ],
+                        "primaryKey": ["index"],
+                    },
+                ),
+                (
+                    "data",
+                    [
+                        OrderedDict([("index", 1.0), ("values", 1)]),
+                        OrderedDict([("index", 2.0), ("values", 1)]),
+                    ],
+                ),
+            ]
+        )
+
+        assert result == expected
+
+    def test_to_json_period_index(self):
+        idx = pd.period_range("2016", freq="Q-JAN", periods=2)
+        data = pd.Series(1, idx)
+        result = data.to_json(orient="table", date_format="iso")
+        result = json.loads(result, object_pairs_hook=OrderedDict)
+        result["schema"].pop("pandas_version")
+
+        fields = [
+            {"freq": "QE-JAN", "name": "index", "type": "datetime"},
+            {"name": "values", "type": "integer"},
+        ]
+
+        schema = {"fields": fields, "primaryKey": ["index"]}
+        data = [
+            OrderedDict([("index", "2015-11-01T00:00:00.000"), ("values", 1)]),
+            OrderedDict([("index", "2016-02-01T00:00:00.000"), ("values", 1)]),
+        ]
+        expected = OrderedDict([("schema", schema), ("data", data)])
+
+        assert result == expected
+
+    def test_to_json_categorical_index(self):
+        data = pd.Series(1, pd.CategoricalIndex(["a", "b"]))
+        result = data.to_json(orient="table", date_format="iso")
+        result = json.loads(result, object_pairs_hook=OrderedDict)
+        result["schema"].pop("pandas_version")
+
+        expected = OrderedDict(
+            [
+                (
+                    "schema",
+                    {
+                        "fields": [
+                            {
+                                "name": "index",
+                                "type": "any",
+                                "constraints": {"enum": ["a", "b"]},
+                                "ordered": False,
+                            },
+                            {"name": "values", "type": "integer"},
+                        ],
+                        "primaryKey": ["index"],
+                    },
+                ),
+                (
+                    "data",
+                    [
+                        OrderedDict([("index", "a"), ("values", 1)]),
+                        OrderedDict([("index", "b"), ("values", 1)]),
+                    ],
+                ),
+            ]
+        )
+
+        assert result == expected
+
+    def test_date_format_raises(self, df_table):
+        msg = (
+            "Trying to write with `orient='table'` and `date_format='epoch'`. Table "
+            "Schema requires dates to be formatted with `date_format='iso'`"
+        )
+        with pytest.raises(ValueError, match=msg):
+            df_table.to_json(orient="table", date_format="epoch")
+
+        # others work
+        df_table.to_json(orient="table", date_format="iso")
+        df_table.to_json(orient="table")
+
+    def test_convert_pandas_type_to_json_field_int(self, index_or_series):
+        kind = index_or_series
+        data = [1, 2, 3]
+        result = convert_pandas_type_to_json_field(kind(data, name="name"))
+        expected = {"name": "name", "type": "integer"}
+        assert result == expected
+
+    def test_convert_pandas_type_to_json_field_float(self, index_or_series):
+        kind = index_or_series
+        data = [1.0, 2.0, 3.0]
+        result = convert_pandas_type_to_json_field(kind(data, name="name"))
+        expected = {"name": "name", "type": "number"}
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "dt_args,extra_exp", [({}, {}), ({"utc": True}, {"tz": "UTC"})]
+    )
+    @pytest.mark.parametrize("wrapper", [None, pd.Series])
+    def test_convert_pandas_type_to_json_field_datetime(
+        self, dt_args, extra_exp, wrapper
+    ):
+        data = [1.0, 2.0, 3.0]
+        data = pd.to_datetime(data, **dt_args)
+        if wrapper is pd.Series:
+            data = pd.Series(data, name="values")
+        result = convert_pandas_type_to_json_field(data)
+        expected = {"name": "values", "type": "datetime"}
+        expected.update(extra_exp)
+        assert result == expected
+
+    def test_convert_pandas_type_to_json_period_range(self):
+        arr = pd.period_range("2016", freq="Y-DEC", periods=4)
+        result = convert_pandas_type_to_json_field(arr)
+        expected = {"name": "values", "type": "datetime", "freq": "YE-DEC"}
+        assert result == expected
+
+    @pytest.mark.parametrize("kind", [pd.Categorical, pd.CategoricalIndex])
+    @pytest.mark.parametrize("ordered", [True, False])
+    def test_convert_pandas_type_to_json_field_categorical(self, kind, ordered):
+        data = ["a", "b", "c"]
+        if kind is pd.Categorical:
+            arr = pd.Series(kind(data, ordered=ordered), name="cats")
+        elif kind is pd.CategoricalIndex:
+            arr = kind(data, ordered=ordered, name="cats")
+
+        result = convert_pandas_type_to_json_field(arr)
+        expected = {
+            "name": "cats",
+            "type": "any",
+            "constraints": {"enum": data},
+            "ordered": ordered,
+        }
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "inp,exp",
+        [
+            ({"type": "integer"}, "int64"),
+            ({"type": "number"}, "float64"),
+            ({"type": "boolean"}, "bool"),
+            ({"type": "duration"}, "timedelta64"),
+            ({"type": "datetime"}, "datetime64[ns]"),
+            ({"type": "datetime", "tz": "US/Hawaii"}, "datetime64[ns, US/Hawaii]"),
+            ({"type": "any"}, "object"),
+            (
+                {
+                    "type": "any",
+                    "constraints": {"enum": ["a", "b", "c"]},
+                    "ordered": False,
+                },
+                CategoricalDtype(categories=["a", "b", "c"], ordered=False),
+            ),
+            (
+                {
+                    "type": "any",
+                    "constraints": {"enum": ["a", "b", "c"]},
+                    "ordered": True,
+                },
+                CategoricalDtype(categories=["a", "b", "c"], ordered=True),
+            ),
+            ({"type": "string"}, "object"),
+        ],
+    )
+    def test_convert_json_field_to_pandas_type(self, inp, exp):
+        field = {"name": "foo"}
+        field.update(inp)
+        assert convert_json_field_to_pandas_type(field) == exp
+
+    @pytest.mark.parametrize("inp", ["geopoint", "geojson", "fake_type"])
+    def test_convert_json_field_to_pandas_type_raises(self, inp):
+        field = {"type": inp}
+        with pytest.raises(
+            ValueError, match=f"Unsupported or invalid field type: {inp}"
+        ):
+            convert_json_field_to_pandas_type(field)
+
+    def test_categorical(self):
+        s = pd.Series(pd.Categorical(["a", "b", "a"]))
+        s.index.name = "idx"
+        result = s.to_json(orient="table", date_format="iso")
+        result = json.loads(result, object_pairs_hook=OrderedDict)
+        result["schema"].pop("pandas_version")
+
+        fields = [
+            {"name": "idx", "type": "integer"},
+            {
+                "constraints": {"enum": ["a", "b"]},
+                "name": "values",
+                "ordered": False,
+                "type": "any",
+            },
+        ]
+
+        expected = OrderedDict(
+            [
+                ("schema", {"fields": fields, "primaryKey": ["idx"]}),
+                (
+                    "data",
+                    [
+                        OrderedDict([("idx", 0), ("values", "a")]),
+                        OrderedDict([("idx", 1), ("values", "b")]),
+                        OrderedDict([("idx", 2), ("values", "a")]),
+                    ],
+                ),
+            ]
+        )
+
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "idx,nm,prop",
+        [
+            (pd.Index([1]), "index", "name"),
+            (pd.Index([1], name="myname"), "myname", "name"),
+            (
+                pd.MultiIndex.from_product([("a", "b"), ("c", "d")]),
+                ["level_0", "level_1"],
+                "names",
+            ),
+            (
+                pd.MultiIndex.from_product(
+                    [("a", "b"), ("c", "d")], names=["n1", "n2"]
+                ),
+                ["n1", "n2"],
+                "names",
+            ),
+            (
+                pd.MultiIndex.from_product(
+                    [("a", "b"), ("c", "d")], names=["n1", None]
+                ),
+                ["n1", "level_1"],
+                "names",
+            ),
+        ],
+    )
+    def test_set_names_unset(self, idx, nm, prop):
+        data = pd.Series(1, idx)
+        result = set_default_names(data)
+        assert getattr(result.index, prop) == nm
+
+    @pytest.mark.parametrize(
+        "idx",
+        [
+            pd.Index([], name="index"),
+            pd.MultiIndex.from_arrays([["foo"], ["bar"]], names=("level_0", "level_1")),
+            pd.MultiIndex.from_arrays([["foo"], ["bar"]], names=("foo", "level_1")),
+        ],
+    )
+    def test_warns_non_roundtrippable_names(self, idx):
+        # GH 19130
+        df = DataFrame(index=idx)
+        df.index.name = "index"
+        with tm.assert_produces_warning():
+            set_default_names(df)
+
+    def test_timestamp_in_columns(self):
+        df = DataFrame(
+            [[1, 2]], columns=[pd.Timestamp("2016"), pd.Timedelta(10, unit="s")]
+        )
+        result = df.to_json(orient="table")
+        js = json.loads(result)
+        assert js["schema"]["fields"][1]["name"] == "2016-01-01T00:00:00.000"
+        assert js["schema"]["fields"][2]["name"] == "P0DT0H0M10S"
+
+    @pytest.mark.parametrize(
+        "case",
+        [
+            pd.Series([1], index=pd.Index([1], name="a"), name="a"),
+            DataFrame({"A": [1]}, index=pd.Index([1], name="A")),
+            DataFrame(
+                {"A": [1]},
+                index=pd.MultiIndex.from_arrays([["a"], [1]], names=["A", "a"]),
+            ),
+        ],
+    )
+    def test_overlapping_names(self, case):
+        with pytest.raises(ValueError, match="Overlapping"):
+            case.to_json(orient="table")
+
+    def test_mi_falsey_name(self):
+        # GH 16203
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((4, 4)),
+            index=pd.MultiIndex.from_product([("A", "B"), ("a", "b")]),
+        )
+        result = [x["name"] for x in build_table_schema(df)["fields"]]
+        assert result == ["level_0", "level_1", 0, 1, 2, 3]
+
+
+class TestTableOrientReader:
+    @pytest.mark.parametrize(
+        "index_nm",
+        [None, "idx", pytest.param("index", marks=pytest.mark.xfail), "level_0"],
+    )
+    @pytest.mark.parametrize(
+        "vals",
+        [
+            {"ints": [1, 2, 3, 4]},
+            {"objects": ["a", "b", "c", "d"]},
+            {"objects": ["1", "2", "3", "4"]},
+            {"date_ranges": pd.date_range("2016-01-01", freq="d", periods=4)},
+            {"categoricals": pd.Series(pd.Categorical(["a", "b", "c", "c"]))},
+            {
+                "ordered_cats": pd.Series(
+                    pd.Categorical(["a", "b", "c", "c"], ordered=True)
+                )
+            },
+            {"floats": [1.0, 2.0, 3.0, 4.0]},
+            {"floats": [1.1, 2.2, 3.3, 4.4]},
+            {"bools": [True, False, False, True]},
+            {
+                "timezones": pd.date_range(
+                    "2016-01-01", freq="d", periods=4, tz="US/Central"
+                )  # added in # GH 35973
+            },
+        ],
+    )
+    def test_read_json_table_orient(self, index_nm, vals, recwarn):
+        df = DataFrame(vals, index=pd.Index(range(4), name=index_nm))
+        out = df.to_json(orient="table")
+        result = pd.read_json(out, orient="table")
+        tm.assert_frame_equal(df, result)
+
+    @pytest.mark.parametrize("index_nm", [None, "idx", "index"])
+    @pytest.mark.parametrize(
+        "vals",
+        [{"timedeltas": pd.timedelta_range("1h", periods=4, freq="min")}],
+    )
+    def test_read_json_table_orient_raises(self, index_nm, vals, recwarn):
+        df = DataFrame(vals, index=pd.Index(range(4), name=index_nm))
+        out = df.to_json(orient="table")
+        with pytest.raises(NotImplementedError, match="can not yet read "):
+            pd.read_json(out, orient="table")
+
+    @pytest.mark.parametrize(
+        "index_nm",
+        [None, "idx", pytest.param("index", marks=pytest.mark.xfail), "level_0"],
+    )
+    @pytest.mark.parametrize(
+        "vals",
+        [
+            {"ints": [1, 2, 3, 4]},
+            {"objects": ["a", "b", "c", "d"]},
+            {"objects": ["1", "2", "3", "4"]},
+            {"date_ranges": pd.date_range("2016-01-01", freq="d", periods=4)},
+            {"categoricals": pd.Series(pd.Categorical(["a", "b", "c", "c"]))},
+            {
+                "ordered_cats": pd.Series(
+                    pd.Categorical(["a", "b", "c", "c"], ordered=True)
+                )
+            },
+            {"floats": [1.0, 2.0, 3.0, 4.0]},
+            {"floats": [1.1, 2.2, 3.3, 4.4]},
+            {"bools": [True, False, False, True]},
+            {
+                "timezones": pd.date_range(
+                    "2016-01-01", freq="d", periods=4, tz="US/Central"
+                )  # added in # GH 35973
+            },
+        ],
+    )
+    def test_read_json_table_period_orient(self, index_nm, vals, recwarn):
+        df = DataFrame(
+            vals,
+            index=pd.Index(
+                (pd.Period(f"2022Q{q}") for q in range(1, 5)), name=index_nm
+            ),
+        )
+        out = df.to_json(orient="table")
+        result = pd.read_json(out, orient="table")
+        tm.assert_frame_equal(df, result)
+
+    @pytest.mark.parametrize(
+        "idx",
+        [
+            pd.Index(range(4)),
+            pd.date_range(
+                "2020-08-30",
+                freq="d",
+                periods=4,
+            )._with_freq(None),
+            pd.date_range(
+                "2020-08-30", freq="d", periods=4, tz="US/Central"
+            )._with_freq(None),
+            pd.MultiIndex.from_product(
+                [
+                    pd.date_range("2020-08-30", freq="d", periods=2, tz="US/Central"),
+                    ["x", "y"],
+                ],
+            ),
+        ],
+    )
+    @pytest.mark.parametrize(
+        "vals",
+        [
+            {"floats": [1.1, 2.2, 3.3, 4.4]},
+            {"dates": pd.date_range("2020-08-30", freq="d", periods=4)},
+            {
+                "timezones": pd.date_range(
+                    "2020-08-30", freq="d", periods=4, tz="Europe/London"
+                )
+            },
+        ],
+    )
+    def test_read_json_table_timezones_orient(self, idx, vals, recwarn):
+        # GH 35973
+        df = DataFrame(vals, index=idx)
+        out = df.to_json(orient="table")
+        result = pd.read_json(out, orient="table")
+        tm.assert_frame_equal(df, result)
+
+    def test_comprehensive(self):
+        df = DataFrame(
+            {
+                "A": [1, 2, 3, 4],
+                "B": ["a", "b", "c", "c"],
+                "C": pd.date_range("2016-01-01", freq="d", periods=4),
+                # 'D': pd.timedelta_range('1h', periods=4, freq='min'),
+                "E": pd.Series(pd.Categorical(["a", "b", "c", "c"])),
+                "F": pd.Series(pd.Categorical(["a", "b", "c", "c"], ordered=True)),
+                "G": [1.1, 2.2, 3.3, 4.4],
+                "H": pd.date_range("2016-01-01", freq="d", periods=4, tz="US/Central"),
+                "I": [True, False, False, True],
+            },
+            index=pd.Index(range(4), name="idx"),
+        )
+
+        out = StringIO(df.to_json(orient="table"))
+        result = pd.read_json(out, orient="table")
+        tm.assert_frame_equal(df, result)
+
+    @pytest.mark.parametrize(
+        "index_names",
+        [[None, None], ["foo", "bar"], ["foo", None], [None, "foo"], ["index", "foo"]],
+    )
+    def test_multiindex(self, index_names):
+        # GH 18912
+        df = DataFrame(
+            [["Arr", "alpha", [1, 2, 3, 4]], ["Bee", "Beta", [10, 20, 30, 40]]],
+            index=[["A", "B"], ["Null", "Eins"]],
+            columns=["Aussprache", "Griechisch", "Args"],
+        )
+        df.index.names = index_names
+        out = StringIO(df.to_json(orient="table"))
+        result = pd.read_json(out, orient="table")
+        tm.assert_frame_equal(df, result)
+
+    def test_empty_frame_roundtrip(self):
+        # GH 21287
+        df = DataFrame(columns=["a", "b", "c"])
+        expected = df.copy()
+        out = StringIO(df.to_json(orient="table"))
+        result = pd.read_json(out, orient="table")
+        tm.assert_frame_equal(expected, result)
+
+    def test_read_json_orient_table_old_schema_version(self):
+        df_json = """
+        {
+            "schema":{
+                "fields":[
+                    {"name":"index","type":"integer"},
+                    {"name":"a","type":"string"}
+                ],
+                "primaryKey":["index"],
+                "pandas_version":"0.20.0"
+            },
+            "data":[
+                {"index":0,"a":1},
+                {"index":1,"a":2.0},
+                {"index":2,"a":"s"}
+            ]
+        }
+        """
+        expected = DataFrame({"a": [1, 2.0, "s"]})
+        result = pd.read_json(StringIO(df_json), orient="table")
+        tm.assert_frame_equal(expected, result)
+
+    @pytest.mark.parametrize("freq", ["M", "2M", "Q", "2Q", "Y", "2Y"])
+    def test_read_json_table_orient_period_depr_freq(self, freq, recwarn):
+        # GH#9586
+        df = DataFrame(
+            {"ints": [1, 2]},
+            index=pd.PeriodIndex(["2020-01", "2021-06"], freq=freq),
+        )
+        out = df.to_json(orient="table")
+        result = pd.read_json(out, orient="table")
+        tm.assert_frame_equal(df, result)

venv/lib/python3.10/site-packages/pandas/tests/io/json/test_readlines.py

@@ -0,0 +1,543 @@
+from collections.abc import Iterator
+from io import StringIO
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    read_json,
+)
+import pandas._testing as tm
+
+from pandas.io.json._json import JsonReader
+
+pytestmark = pytest.mark.filterwarnings(
+    "ignore:Passing a BlockManager to DataFrame:DeprecationWarning"
+)
+
+
+@pytest.fixture
+def lines_json_df():
+    df = DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
+    return df.to_json(lines=True, orient="records")
+
+
+@pytest.fixture(params=["ujson", "pyarrow"])
+def engine(request):
+    if request.param == "pyarrow":
+        pytest.importorskip("pyarrow.json")
+    return request.param
+
+
+def test_read_jsonl():
+    # GH9180
+    result = read_json(StringIO('{"a": 1, "b": 2}\n{"b":2, "a" :1}\n'), lines=True)
+    expected = DataFrame([[1, 2], [1, 2]], columns=["a", "b"])
+    tm.assert_frame_equal(result, expected)
+
+
+def test_read_jsonl_engine_pyarrow(datapath, engine):
+    result = read_json(
+        datapath("io", "json", "data", "line_delimited.json"),
+        lines=True,
+        engine=engine,
+    )
+    expected = DataFrame({"a": [1, 3, 5], "b": [2, 4, 6]})
+    tm.assert_frame_equal(result, expected)
+
+
+def test_read_datetime(request, engine):
+    # GH33787
+    if engine == "pyarrow":
+        # GH 48893
+        reason = "Pyarrow only supports a file path as an input and line delimited json"
+        request.applymarker(pytest.mark.xfail(reason=reason, raises=ValueError))
+
+    df = DataFrame(
+        [([1, 2], ["2020-03-05", "2020-04-08T09:58:49+00:00"], "hector")],
+        columns=["accounts", "date", "name"],
+    )
+    json_line = df.to_json(lines=True, orient="records")
+
+    if engine == "pyarrow":
+        result = read_json(StringIO(json_line), engine=engine)
+    else:
+        result = read_json(StringIO(json_line), engine=engine)
+    expected = DataFrame(
+        [[1, "2020-03-05", "hector"], [2, "2020-04-08T09:58:49+00:00", "hector"]],
+        columns=["accounts", "date", "name"],
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_read_jsonl_unicode_chars():
+    # GH15132: non-ascii unicode characters
+    # \u201d == RIGHT DOUBLE QUOTATION MARK
+
+    # simulate file handle
+    json = '{"a": "foo”", "b": "bar"}\n{"a": "foo", "b": "bar"}\n'
+    json = StringIO(json)
+    result = read_json(json, lines=True)
+    expected = DataFrame([["foo\u201d", "bar"], ["foo", "bar"]], columns=["a", "b"])
+    tm.assert_frame_equal(result, expected)
+
+    # simulate string
+    json = '{"a": "foo”", "b": "bar"}\n{"a": "foo", "b": "bar"}\n'
+    result = read_json(StringIO(json), lines=True)
+    expected = DataFrame([["foo\u201d", "bar"], ["foo", "bar"]], columns=["a", "b"])
+    tm.assert_frame_equal(result, expected)
+
+
+def test_to_jsonl():
+    # GH9180
+    df = DataFrame([[1, 2], [1, 2]], columns=["a", "b"])
+    result = df.to_json(orient="records", lines=True)
+    expected = '{"a":1,"b":2}\n{"a":1,"b":2}\n'
+    assert result == expected
+
+    df = DataFrame([["foo}", "bar"], ['foo"', "bar"]], columns=["a", "b"])
+    result = df.to_json(orient="records", lines=True)
+    expected = '{"a":"foo}","b":"bar"}\n{"a":"foo\\"","b":"bar"}\n'
+    assert result == expected
+    tm.assert_frame_equal(read_json(StringIO(result), lines=True), df)
+
+    # GH15096: escaped characters in columns and data
+    df = DataFrame([["foo\\", "bar"], ['foo"', "bar"]], columns=["a\\", "b"])
+    result = df.to_json(orient="records", lines=True)
+    expected = '{"a\\\\":"foo\\\\","b":"bar"}\n{"a\\\\":"foo\\"","b":"bar"}\n'
+    assert result == expected
+    tm.assert_frame_equal(read_json(StringIO(result), lines=True), df)
+
+
+def test_to_jsonl_count_new_lines():
+    # GH36888
+    df = DataFrame([[1, 2], [1, 2]], columns=["a", "b"])
+    actual_new_lines_count = df.to_json(orient="records", lines=True).count("\n")
+    expected_new_lines_count = 2
+    assert actual_new_lines_count == expected_new_lines_count
+
+
+@pytest.mark.parametrize("chunksize", [1, 1.0])
+def test_readjson_chunks(request, lines_json_df, chunksize, engine):
+    # Basic test that read_json(chunks=True) gives the same result as
+    # read_json(chunks=False)
+    # GH17048: memory usage when lines=True
+
+    if engine == "pyarrow":
+        # GH 48893
+        reason = (
+            "Pyarrow only supports a file path as an input and line delimited json"
+            "and doesn't support chunksize parameter."
+        )
+        request.applymarker(pytest.mark.xfail(reason=reason, raises=ValueError))
+
+    unchunked = read_json(StringIO(lines_json_df), lines=True)
+    with read_json(
+        StringIO(lines_json_df), lines=True, chunksize=chunksize, engine=engine
+    ) as reader:
+        chunked = pd.concat(reader)
+
+    tm.assert_frame_equal(chunked, unchunked)
+
+
+def test_readjson_chunksize_requires_lines(lines_json_df, engine):
+    msg = "chunksize can only be passed if lines=True"
+    with pytest.raises(ValueError, match=msg):
+        with read_json(
+            StringIO(lines_json_df), lines=False, chunksize=2, engine=engine
+        ) as _:
+            pass
+
+
+def test_readjson_chunks_series(request, engine):
+    if engine == "pyarrow":
+        # GH 48893
+        reason = (
+            "Pyarrow only supports a file path as an input and line delimited json"
+            "and doesn't support chunksize parameter."
+        )
+        request.applymarker(pytest.mark.xfail(reason=reason))
+
+    # Test reading line-format JSON to Series with chunksize param
+    s = pd.Series({"A": 1, "B": 2})
+
+    strio = StringIO(s.to_json(lines=True, orient="records"))
+    unchunked = read_json(strio, lines=True, typ="Series", engine=engine)
+
+    strio = StringIO(s.to_json(lines=True, orient="records"))
+    with read_json(
+        strio, lines=True, typ="Series", chunksize=1, engine=engine
+    ) as reader:
+        chunked = pd.concat(reader)
+
+    tm.assert_series_equal(chunked, unchunked)
+
+
+def test_readjson_each_chunk(request, lines_json_df, engine):
+    if engine == "pyarrow":
+        # GH 48893
+        reason = (
+            "Pyarrow only supports a file path as an input and line delimited json"
+            "and doesn't support chunksize parameter."
+        )
+        request.applymarker(pytest.mark.xfail(reason=reason, raises=ValueError))
+
+    # Other tests check that the final result of read_json(chunksize=True)
+    # is correct. This checks the intermediate chunks.
+    with read_json(
+        StringIO(lines_json_df), lines=True, chunksize=2, engine=engine
+    ) as reader:
+        chunks = list(reader)
+    assert chunks[0].shape == (2, 2)
+    assert chunks[1].shape == (1, 2)
+
+
+def test_readjson_chunks_from_file(request, engine):
+    if engine == "pyarrow":
+        # GH 48893
+        reason = (
+            "Pyarrow only supports a file path as an input and line delimited json"
+            "and doesn't support chunksize parameter."
+        )
+        request.applymarker(pytest.mark.xfail(reason=reason, raises=ValueError))
+
+    with tm.ensure_clean("test.json") as path:
+        df = DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
+        df.to_json(path, lines=True, orient="records")
+        with read_json(path, lines=True, chunksize=1, engine=engine) as reader:
+            chunked = pd.concat(reader)
+        unchunked = read_json(path, lines=True, engine=engine)
+        tm.assert_frame_equal(unchunked, chunked)
+
+
+@pytest.mark.parametrize("chunksize", [None, 1])
+def test_readjson_chunks_closes(chunksize):
+    with tm.ensure_clean("test.json") as path:
+        df = DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
+        df.to_json(path, lines=True, orient="records")
+        reader = JsonReader(
+            path,
+            orient=None,
+            typ="frame",
+            dtype=True,
+            convert_axes=True,
+            convert_dates=True,
+            keep_default_dates=True,
+            precise_float=False,
+            date_unit=None,
+            encoding=None,
+            lines=True,
+            chunksize=chunksize,
+            compression=None,
+            nrows=None,
+        )
+        with reader:
+            reader.read()
+        assert (
+            reader.handles.handle.closed
+        ), f"didn't close stream with chunksize = {chunksize}"
+
+
+@pytest.mark.parametrize("chunksize", [0, -1, 2.2, "foo"])
+def test_readjson_invalid_chunksize(lines_json_df, chunksize, engine):
+    msg = r"'chunksize' must be an integer >=1"
+
+    with pytest.raises(ValueError, match=msg):
+        with read_json(
+            StringIO(lines_json_df), lines=True, chunksize=chunksize, engine=engine
+        ) as _:
+            pass
+
+
+@pytest.mark.parametrize("chunksize", [None, 1, 2])
+def test_readjson_chunks_multiple_empty_lines(chunksize):
+    j = """
+
+    {"A":1,"B":4}
+
+
+
+    {"A":2,"B":5}
+
+
+
+
+
+
+
+    {"A":3,"B":6}
+    """
+    orig = DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
+    test = read_json(StringIO(j), lines=True, chunksize=chunksize)
+    if chunksize is not None:
+        with test:
+            test = pd.concat(test)
+    tm.assert_frame_equal(orig, test, obj=f"chunksize: {chunksize}")
+
+
+def test_readjson_unicode(request, monkeypatch, engine):
+    if engine == "pyarrow":
+        # GH 48893
+        reason = (
+            "Pyarrow only supports a file path as an input and line delimited json"
+            "and doesn't support chunksize parameter."
+        )
+        request.applymarker(pytest.mark.xfail(reason=reason, raises=ValueError))
+
+    with tm.ensure_clean("test.json") as path:
+        monkeypatch.setattr("locale.getpreferredencoding", lambda do_setlocale: "cp949")
+        with open(path, "w", encoding="utf-8") as f:
+            f.write('{"£©µÀÆÖÞßéöÿ":["АБВГДабвгд가"]}')
+
+        result = read_json(path, engine=engine)
+        expected = DataFrame({"£©µÀÆÖÞßéöÿ": ["АБВГДабвгд가"]})
+        tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("nrows", [1, 2])
+def test_readjson_nrows(nrows, engine):
+    # GH 33916
+    # Test reading line-format JSON to Series with nrows param
+    jsonl = """{"a": 1, "b": 2}
+        {"a": 3, "b": 4}
+        {"a": 5, "b": 6}
+        {"a": 7, "b": 8}"""
+    result = read_json(StringIO(jsonl), lines=True, nrows=nrows)
+    expected = DataFrame({"a": [1, 3, 5, 7], "b": [2, 4, 6, 8]}).iloc[:nrows]
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("nrows,chunksize", [(2, 2), (4, 2)])
+def test_readjson_nrows_chunks(request, nrows, chunksize, engine):
+    # GH 33916
+    # Test reading line-format JSON to Series with nrows and chunksize param
+    if engine == "pyarrow":
+        # GH 48893
+        reason = (
+            "Pyarrow only supports a file path as an input and line delimited json"
+            "and doesn't support chunksize parameter."
+        )
+        request.applymarker(pytest.mark.xfail(reason=reason, raises=ValueError))
+
+    jsonl = """{"a": 1, "b": 2}
+        {"a": 3, "b": 4}
+        {"a": 5, "b": 6}
+        {"a": 7, "b": 8}"""
+
+    if engine != "pyarrow":
+        with read_json(
+            StringIO(jsonl), lines=True, nrows=nrows, chunksize=chunksize, engine=engine
+        ) as reader:
+            chunked = pd.concat(reader)
+    else:
+        with read_json(
+            jsonl, lines=True, nrows=nrows, chunksize=chunksize, engine=engine
+        ) as reader:
+            chunked = pd.concat(reader)
+    expected = DataFrame({"a": [1, 3, 5, 7], "b": [2, 4, 6, 8]}).iloc[:nrows]
+    tm.assert_frame_equal(chunked, expected)
+
+
+def test_readjson_nrows_requires_lines(engine):
+    # GH 33916
+    # Test ValueError raised if nrows is set without setting lines in read_json
+    jsonl = """{"a": 1, "b": 2}
+        {"a": 3, "b": 4}
+        {"a": 5, "b": 6}
+        {"a": 7, "b": 8}"""
+    msg = "nrows can only be passed if lines=True"
+    with pytest.raises(ValueError, match=msg):
+        read_json(jsonl, lines=False, nrows=2, engine=engine)
+
+
+def test_readjson_lines_chunks_fileurl(request, datapath, engine):
+    # GH 27135
+    # Test reading line-format JSON from file url
+    if engine == "pyarrow":
+        # GH 48893
+        reason = (
+            "Pyarrow only supports a file path as an input and line delimited json"
+            "and doesn't support chunksize parameter."
+        )
+        request.applymarker(pytest.mark.xfail(reason=reason, raises=ValueError))
+
+    df_list_expected = [
+        DataFrame([[1, 2]], columns=["a", "b"], index=[0]),
+        DataFrame([[3, 4]], columns=["a", "b"], index=[1]),
+        DataFrame([[5, 6]], columns=["a", "b"], index=[2]),
+    ]
+    os_path = datapath("io", "json", "data", "line_delimited.json")
+    file_url = Path(os_path).as_uri()
+    with read_json(file_url, lines=True, chunksize=1, engine=engine) as url_reader:
+        for index, chuck in enumerate(url_reader):
+            tm.assert_frame_equal(chuck, df_list_expected[index])
+
+
+def test_chunksize_is_incremental():
+    # See https://github.com/pandas-dev/pandas/issues/34548
+    jsonl = (
+        """{"a": 1, "b": 2}
+        {"a": 3, "b": 4}
+        {"a": 5, "b": 6}
+        {"a": 7, "b": 8}\n"""
+        * 1000
+    )
+
+    class MyReader:
+        def __init__(self, contents) -> None:
+            self.read_count = 0
+            self.stringio = StringIO(contents)
+
+        def read(self, *args):
+            self.read_count += 1
+            return self.stringio.read(*args)
+
+        def __iter__(self) -> Iterator:
+            self.read_count += 1
+            return iter(self.stringio)
+
+    reader = MyReader(jsonl)
+    assert len(list(read_json(reader, lines=True, chunksize=100))) > 1
+    assert reader.read_count > 10
+
+
+@pytest.mark.parametrize("orient_", ["split", "index", "table"])
+def test_to_json_append_orient(orient_):
+    # GH 35849
+    # Test ValueError when orient is not 'records'
+    df = DataFrame({"col1": [1, 2], "col2": ["a", "b"]})
+    msg = (
+        r"mode='a' \(append\) is only supported when "
+        "lines is True and orient is 'records'"
+    )
+    with pytest.raises(ValueError, match=msg):
+        df.to_json(mode="a", orient=orient_)
+
+
+def test_to_json_append_lines():
+    # GH 35849
+    # Test ValueError when lines is not True
+    df = DataFrame({"col1": [1, 2], "col2": ["a", "b"]})
+    msg = (
+        r"mode='a' \(append\) is only supported when "
+        "lines is True and orient is 'records'"
+    )
+    with pytest.raises(ValueError, match=msg):
+        df.to_json(mode="a", lines=False, orient="records")
+
+
+@pytest.mark.parametrize("mode_", ["r", "x"])
+def test_to_json_append_mode(mode_):
+    # GH 35849
+    # Test ValueError when mode is not supported option
+    df = DataFrame({"col1": [1, 2], "col2": ["a", "b"]})
+    msg = (
+        f"mode={mode_} is not a valid option."
+        "Only 'w' and 'a' are currently supported."
+    )
+    with pytest.raises(ValueError, match=msg):
+        df.to_json(mode=mode_, lines=False, orient="records")
+
+
+def test_to_json_append_output_consistent_columns():
+    # GH 35849
+    # Testing that resulting output reads in as expected.
+    # Testing same columns, new rows
+    df1 = DataFrame({"col1": [1, 2], "col2": ["a", "b"]})
+    df2 = DataFrame({"col1": [3, 4], "col2": ["c", "d"]})
+
+    expected = DataFrame({"col1": [1, 2, 3, 4], "col2": ["a", "b", "c", "d"]})
+    with tm.ensure_clean("test.json") as path:
+        # Save dataframes to the same file
+        df1.to_json(path, lines=True, orient="records")
+        df2.to_json(path, mode="a", lines=True, orient="records")
+
+        # Read path file
+        result = read_json(path, lines=True)
+        tm.assert_frame_equal(result, expected)
+
+
+def test_to_json_append_output_inconsistent_columns():
+    # GH 35849
+    # Testing that resulting output reads in as expected.
+    # Testing one new column, one old column, new rows
+    df1 = DataFrame({"col1": [1, 2], "col2": ["a", "b"]})
+    df3 = DataFrame({"col2": ["e", "f"], "col3": ["!", "#"]})
+
+    expected = DataFrame(
+        {
+            "col1": [1, 2, None, None],
+            "col2": ["a", "b", "e", "f"],
+            "col3": [np.nan, np.nan, "!", "#"],
+        }
+    )
+    with tm.ensure_clean("test.json") as path:
+        # Save dataframes to the same file
+        df1.to_json(path, mode="a", lines=True, orient="records")
+        df3.to_json(path, mode="a", lines=True, orient="records")
+
+        # Read path file
+        result = read_json(path, lines=True)
+        tm.assert_frame_equal(result, expected)
+
+
+def test_to_json_append_output_different_columns():
+    # GH 35849
+    # Testing that resulting output reads in as expected.
+    # Testing same, differing and new columns
+    df1 = DataFrame({"col1": [1, 2], "col2": ["a", "b"]})
+    df2 = DataFrame({"col1": [3, 4], "col2": ["c", "d"]})
+    df3 = DataFrame({"col2": ["e", "f"], "col3": ["!", "#"]})
+    df4 = DataFrame({"col4": [True, False]})
+
+    expected = DataFrame(
+        {
+            "col1": [1, 2, 3, 4, None, None, None, None],
+            "col2": ["a", "b", "c", "d", "e", "f", np.nan, np.nan],
+            "col3": [np.nan, np.nan, np.nan, np.nan, "!", "#", np.nan, np.nan],
+            "col4": [None, None, None, None, None, None, True, False],
+        }
+    ).astype({"col4": "float"})
+    with tm.ensure_clean("test.json") as path:
+        # Save dataframes to the same file
+        df1.to_json(path, mode="a", lines=True, orient="records")
+        df2.to_json(path, mode="a", lines=True, orient="records")
+        df3.to_json(path, mode="a", lines=True, orient="records")
+        df4.to_json(path, mode="a", lines=True, orient="records")
+
+        # Read path file
+        result = read_json(path, lines=True)
+        tm.assert_frame_equal(result, expected)
+
+
+def test_to_json_append_output_different_columns_reordered():
+    # GH 35849
+    # Testing that resulting output reads in as expected.
+    # Testing specific result column order.
+    df1 = DataFrame({"col1": [1, 2], "col2": ["a", "b"]})
+    df2 = DataFrame({"col1": [3, 4], "col2": ["c", "d"]})
+    df3 = DataFrame({"col2": ["e", "f"], "col3": ["!", "#"]})
+    df4 = DataFrame({"col4": [True, False]})
+
+    # df4, df3, df2, df1 (in that order)
+    expected = DataFrame(
+        {
+            "col4": [True, False, None, None, None, None, None, None],
+            "col2": [np.nan, np.nan, "e", "f", "c", "d", "a", "b"],
+            "col3": [np.nan, np.nan, "!", "#", np.nan, np.nan, np.nan, np.nan],
+            "col1": [None, None, None, None, 3, 4, 1, 2],
+        }
+    ).astype({"col4": "float"})
+    with tm.ensure_clean("test.json") as path:
+        # Save dataframes to the same file
+        df4.to_json(path, mode="a", lines=True, orient="records")
+        df3.to_json(path, mode="a", lines=True, orient="records")
+        df2.to_json(path, mode="a", lines=True, orient="records")
+        df1.to_json(path, mode="a", lines=True, orient="records")
+
+        # Read path file
+        result = read_json(path, lines=True)
+        tm.assert_frame_equal(result, expected)

venv/lib/python3.10/site-packages/pandas/tests/io/json/test_ujson.py

@@ -0,0 +1,1087 @@
+import calendar
+import datetime
+import decimal
+import json
+import locale
+import math
+import re
+import time
+
+import dateutil
+import numpy as np
+import pytest
+import pytz
+
+import pandas._libs.json as ujson
+from pandas.compat import IS64
+
+from pandas import (
+    DataFrame,
+    DatetimeIndex,
+    Index,
+    NaT,
+    PeriodIndex,
+    Series,
+    Timedelta,
+    Timestamp,
+    date_range,
+)
+import pandas._testing as tm
+
+
+def _clean_dict(d):
+    """
+    Sanitize dictionary for JSON by converting all keys to strings.
+
+    Parameters
+    ----------
+    d : dict
+        The dictionary to convert.
+
+    Returns
+    -------
+    cleaned_dict : dict
+    """
+    return {str(k): v for k, v in d.items()}
+
+
+@pytest.fixture(
+    params=[None, "split", "records", "values", "index"]  # Column indexed by default.
+)
+def orient(request):
+    return request.param
+
+
+class TestUltraJSONTests:
+    @pytest.mark.skipif(not IS64, reason="not compliant on 32-bit, xref #15865")
+    def test_encode_decimal(self):
+        sut = decimal.Decimal("1337.1337")
+        encoded = ujson.ujson_dumps(sut, double_precision=15)
+        decoded = ujson.ujson_loads(encoded)
+        assert decoded == 1337.1337
+
+        sut = decimal.Decimal("0.95")
+        encoded = ujson.ujson_dumps(sut, double_precision=1)
+        assert encoded == "1.0"
+
+        decoded = ujson.ujson_loads(encoded)
+        assert decoded == 1.0
+
+        sut = decimal.Decimal("0.94")
+        encoded = ujson.ujson_dumps(sut, double_precision=1)
+        assert encoded == "0.9"
+
+        decoded = ujson.ujson_loads(encoded)
+        assert decoded == 0.9
+
+        sut = decimal.Decimal("1.95")
+        encoded = ujson.ujson_dumps(sut, double_precision=1)
+        assert encoded == "2.0"
+
+        decoded = ujson.ujson_loads(encoded)
+        assert decoded == 2.0
+
+        sut = decimal.Decimal("-1.95")
+        encoded = ujson.ujson_dumps(sut, double_precision=1)
+        assert encoded == "-2.0"
+
+        decoded = ujson.ujson_loads(encoded)
+        assert decoded == -2.0
+
+        sut = decimal.Decimal("0.995")
+        encoded = ujson.ujson_dumps(sut, double_precision=2)
+        assert encoded == "1.0"
+
+        decoded = ujson.ujson_loads(encoded)
+        assert decoded == 1.0
+
+        sut = decimal.Decimal("0.9995")
+        encoded = ujson.ujson_dumps(sut, double_precision=3)
+        assert encoded == "1.0"
+
+        decoded = ujson.ujson_loads(encoded)
+        assert decoded == 1.0
+
+        sut = decimal.Decimal("0.99999999999999944")
+        encoded = ujson.ujson_dumps(sut, double_precision=15)
+        assert encoded == "1.0"
+
+        decoded = ujson.ujson_loads(encoded)
+        assert decoded == 1.0
+
+    @pytest.mark.parametrize("ensure_ascii", [True, False])
+    def test_encode_string_conversion(self, ensure_ascii):
+        string_input = "A string \\ / \b \f \n \r \t </script> &"
+        not_html_encoded = '"A string \\\\ \\/ \\b \\f \\n \\r \\t <\\/script> &"'
+        html_encoded = (
+            '"A string \\\\ \\/ \\b \\f \\n \\r \\t \\u003c\\/script\\u003e \\u0026"'
+        )
+
+        def helper(expected_output, **encode_kwargs):
+            output = ujson.ujson_dumps(
+                string_input, ensure_ascii=ensure_ascii, **encode_kwargs
+            )
+
+            assert output == expected_output
+            assert string_input == json.loads(output)
+            assert string_input == ujson.ujson_loads(output)
+
+        # Default behavior assumes encode_html_chars=False.
+        helper(not_html_encoded)
+
+        # Make sure explicit encode_html_chars=False works.
+        helper(not_html_encoded, encode_html_chars=False)
+
+        # Make sure explicit encode_html_chars=True does the encoding.
+        helper(html_encoded, encode_html_chars=True)
+
+    @pytest.mark.parametrize(
+        "long_number", [-4342969734183514, -12345678901234.56789012, -528656961.4399388]
+    )
+    def test_double_long_numbers(self, long_number):
+        sut = {"a": long_number}
+        encoded = ujson.ujson_dumps(sut, double_precision=15)
+
+        decoded = ujson.ujson_loads(encoded)
+        assert sut == decoded
+
+    def test_encode_non_c_locale(self):
+        lc_category = locale.LC_NUMERIC
+
+        # We just need one of these locales to work.
+        for new_locale in ("it_IT.UTF-8", "Italian_Italy"):
+            if tm.can_set_locale(new_locale, lc_category):
+                with tm.set_locale(new_locale, lc_category):
+                    assert ujson.ujson_loads(ujson.ujson_dumps(4.78e60)) == 4.78e60
+                    assert ujson.ujson_loads("4.78", precise_float=True) == 4.78
+                break
+
+    def test_decimal_decode_test_precise(self):
+        sut = {"a": 4.56}
+        encoded = ujson.ujson_dumps(sut)
+        decoded = ujson.ujson_loads(encoded, precise_float=True)
+        assert sut == decoded
+
+    def test_encode_double_tiny_exponential(self):
+        num = 1e-40
+        assert num == ujson.ujson_loads(ujson.ujson_dumps(num))
+        num = 1e-100
+        assert num == ujson.ujson_loads(ujson.ujson_dumps(num))
+        num = -1e-45
+        assert num == ujson.ujson_loads(ujson.ujson_dumps(num))
+        num = -1e-145
+        assert np.allclose(num, ujson.ujson_loads(ujson.ujson_dumps(num)))
+
+    @pytest.mark.parametrize("unicode_key", ["key1", "بن"])
+    def test_encode_dict_with_unicode_keys(self, unicode_key):
+        unicode_dict = {unicode_key: "value1"}
+        assert unicode_dict == ujson.ujson_loads(ujson.ujson_dumps(unicode_dict))
+
+    @pytest.mark.parametrize(
+        "double_input", [math.pi, -math.pi]  # Should work with negatives too.
+    )
+    def test_encode_double_conversion(self, double_input):
+        output = ujson.ujson_dumps(double_input)
+        assert round(double_input, 5) == round(json.loads(output), 5)
+        assert round(double_input, 5) == round(ujson.ujson_loads(output), 5)
+
+    def test_encode_with_decimal(self):
+        decimal_input = 1.0
+        output = ujson.ujson_dumps(decimal_input)
+
+        assert output == "1.0"
+
+    def test_encode_array_of_nested_arrays(self):
+        nested_input = [[[[]]]] * 20
+        output = ujson.ujson_dumps(nested_input)
+
+        assert nested_input == json.loads(output)
+        assert nested_input == ujson.ujson_loads(output)
+
+    def test_encode_array_of_doubles(self):
+        doubles_input = [31337.31337, 31337.31337, 31337.31337, 31337.31337] * 10
+        output = ujson.ujson_dumps(doubles_input)
+
+        assert doubles_input == json.loads(output)
+        assert doubles_input == ujson.ujson_loads(output)
+
+    def test_double_precision(self):
+        double_input = 30.012345678901234
+        output = ujson.ujson_dumps(double_input, double_precision=15)
+
+        assert double_input == json.loads(output)
+        assert double_input == ujson.ujson_loads(output)
+
+        for double_precision in (3, 9):
+            output = ujson.ujson_dumps(double_input, double_precision=double_precision)
+            rounded_input = round(double_input, double_precision)
+
+            assert rounded_input == json.loads(output)
+            assert rounded_input == ujson.ujson_loads(output)
+
+    @pytest.mark.parametrize(
+        "invalid_val",
+        [
+            20,
+            -1,
+            "9",
+            None,
+        ],
+    )
+    def test_invalid_double_precision(self, invalid_val):
+        double_input = 30.12345678901234567890
+        expected_exception = ValueError if isinstance(invalid_val, int) else TypeError
+        msg = (
+            r"Invalid value '.*' for option 'double_precision', max is '15'|"
+            r"an integer is required \(got type |"
+            r"object cannot be interpreted as an integer"
+        )
+        with pytest.raises(expected_exception, match=msg):
+            ujson.ujson_dumps(double_input, double_precision=invalid_val)
+
+    def test_encode_string_conversion2(self):
+        string_input = "A string \\ / \b \f \n \r \t"
+        output = ujson.ujson_dumps(string_input)
+
+        assert string_input == json.loads(output)
+        assert string_input == ujson.ujson_loads(output)
+        assert output == '"A string \\\\ \\/ \\b \\f \\n \\r \\t"'
+
+    @pytest.mark.parametrize(
+        "unicode_input",
+        ["Räksmörgås اسامة بن محمد بن عوض بن لادن", "\xe6\x97\xa5\xd1\x88"],
+    )
+    def test_encode_unicode_conversion(self, unicode_input):
+        enc = ujson.ujson_dumps(unicode_input)
+        dec = ujson.ujson_loads(enc)
+
+        assert enc == json.dumps(unicode_input)
+        assert dec == json.loads(enc)
+
+    def test_encode_control_escaping(self):
+        escaped_input = "\x19"
+        enc = ujson.ujson_dumps(escaped_input)
+        dec = ujson.ujson_loads(enc)
+
+        assert escaped_input == dec
+        assert enc == json.dumps(escaped_input)
+
+    def test_encode_unicode_surrogate_pair(self):
+        surrogate_input = "\xf0\x90\x8d\x86"
+        enc = ujson.ujson_dumps(surrogate_input)
+        dec = ujson.ujson_loads(enc)
+
+        assert enc == json.dumps(surrogate_input)
+        assert dec == json.loads(enc)
+
+    def test_encode_unicode_4bytes_utf8(self):
+        four_bytes_input = "\xf0\x91\x80\xb0TRAILINGNORMAL"
+        enc = ujson.ujson_dumps(four_bytes_input)
+        dec = ujson.ujson_loads(enc)
+
+        assert enc == json.dumps(four_bytes_input)
+        assert dec == json.loads(enc)
+
+    def test_encode_unicode_4bytes_utf8highest(self):
+        four_bytes_input = "\xf3\xbf\xbf\xbfTRAILINGNORMAL"
+        enc = ujson.ujson_dumps(four_bytes_input)
+
+        dec = ujson.ujson_loads(enc)
+
+        assert enc == json.dumps(four_bytes_input)
+        assert dec == json.loads(enc)
+
+    def test_encode_unicode_error(self):
+        string = "'\udac0'"
+        msg = (
+            r"'utf-8' codec can't encode character '\\udac0' "
+            r"in position 1: surrogates not allowed"
+        )
+        with pytest.raises(UnicodeEncodeError, match=msg):
+            ujson.ujson_dumps([string])
+
+    def test_encode_array_in_array(self):
+        arr_in_arr_input = [[[[]]]]
+        output = ujson.ujson_dumps(arr_in_arr_input)
+
+        assert arr_in_arr_input == json.loads(output)
+        assert output == json.dumps(arr_in_arr_input)
+        assert arr_in_arr_input == ujson.ujson_loads(output)
+
+    @pytest.mark.parametrize(
+        "num_input",
+        [
+            31337,
+            -31337,  # Negative number.
+            -9223372036854775808,  # Large negative number.
+        ],
+    )
+    def test_encode_num_conversion(self, num_input):
+        output = ujson.ujson_dumps(num_input)
+        assert num_input == json.loads(output)
+        assert output == json.dumps(num_input)
+        assert num_input == ujson.ujson_loads(output)
+
+    def test_encode_list_conversion(self):
+        list_input = [1, 2, 3, 4]
+        output = ujson.ujson_dumps(list_input)
+
+        assert list_input == json.loads(output)
+        assert list_input == ujson.ujson_loads(output)
+
+    def test_encode_dict_conversion(self):
+        dict_input = {"k1": 1, "k2": 2, "k3": 3, "k4": 4}
+        output = ujson.ujson_dumps(dict_input)
+
+        assert dict_input == json.loads(output)
+        assert dict_input == ujson.ujson_loads(output)
+
+    @pytest.mark.parametrize("builtin_value", [None, True, False])
+    def test_encode_builtin_values_conversion(self, builtin_value):
+        output = ujson.ujson_dumps(builtin_value)
+        assert builtin_value == json.loads(output)
+        assert output == json.dumps(builtin_value)
+        assert builtin_value == ujson.ujson_loads(output)
+
+    def test_encode_datetime_conversion(self):
+        datetime_input = datetime.datetime.fromtimestamp(time.time())
+        output = ujson.ujson_dumps(datetime_input, date_unit="s")
+        expected = calendar.timegm(datetime_input.utctimetuple())
+
+        assert int(expected) == json.loads(output)
+        assert int(expected) == ujson.ujson_loads(output)
+
+    def test_encode_date_conversion(self):
+        date_input = datetime.date.fromtimestamp(time.time())
+        output = ujson.ujson_dumps(date_input, date_unit="s")
+
+        tup = (date_input.year, date_input.month, date_input.day, 0, 0, 0)
+        expected = calendar.timegm(tup)
+
+        assert int(expected) == json.loads(output)
+        assert int(expected) == ujson.ujson_loads(output)
+
+    @pytest.mark.parametrize(
+        "test",
+        [datetime.time(), datetime.time(1, 2, 3), datetime.time(10, 12, 15, 343243)],
+    )
+    def test_encode_time_conversion_basic(self, test):
+        output = ujson.ujson_dumps(test)
+        expected = f'"{test.isoformat()}"'
+        assert expected == output
+
+    def test_encode_time_conversion_pytz(self):
+        # see gh-11473: to_json segfaults with timezone-aware datetimes
+        test = datetime.time(10, 12, 15, 343243, pytz.utc)
+        output = ujson.ujson_dumps(test)
+        expected = f'"{test.isoformat()}"'
+        assert expected == output
+
+    def test_encode_time_conversion_dateutil(self):
+        # see gh-11473: to_json segfaults with timezone-aware datetimes
+        test = datetime.time(10, 12, 15, 343243, dateutil.tz.tzutc())
+        output = ujson.ujson_dumps(test)
+        expected = f'"{test.isoformat()}"'
+        assert expected == output
+
+    @pytest.mark.parametrize(
+        "decoded_input", [NaT, np.datetime64("NaT"), np.nan, np.inf, -np.inf]
+    )
+    def test_encode_as_null(self, decoded_input):
+        assert ujson.ujson_dumps(decoded_input) == "null", "Expected null"
+
+    def test_datetime_units(self):
+        val = datetime.datetime(2013, 8, 17, 21, 17, 12, 215504)
+        stamp = Timestamp(val).as_unit("ns")
+
+        roundtrip = ujson.ujson_loads(ujson.ujson_dumps(val, date_unit="s"))
+        assert roundtrip == stamp._value // 10**9
+
+        roundtrip = ujson.ujson_loads(ujson.ujson_dumps(val, date_unit="ms"))
+        assert roundtrip == stamp._value // 10**6
+
+        roundtrip = ujson.ujson_loads(ujson.ujson_dumps(val, date_unit="us"))
+        assert roundtrip == stamp._value // 10**3
+
+        roundtrip = ujson.ujson_loads(ujson.ujson_dumps(val, date_unit="ns"))
+        assert roundtrip == stamp._value
+
+        msg = "Invalid value 'foo' for option 'date_unit'"
+        with pytest.raises(ValueError, match=msg):
+            ujson.ujson_dumps(val, date_unit="foo")
+
+    def test_encode_to_utf8(self):
+        unencoded = "\xe6\x97\xa5\xd1\x88"
+
+        enc = ujson.ujson_dumps(unencoded, ensure_ascii=False)
+        dec = ujson.ujson_loads(enc)
+
+        assert enc == json.dumps(unencoded, ensure_ascii=False)
+        assert dec == json.loads(enc)
+
+    def test_decode_from_unicode(self):
+        unicode_input = '{"obj": 31337}'
+
+        dec1 = ujson.ujson_loads(unicode_input)
+        dec2 = ujson.ujson_loads(str(unicode_input))
+
+        assert dec1 == dec2
+
+    def test_encode_recursion_max(self):
+        # 8 is the max recursion depth
+
+        class O2:
+            member = 0
+
+        class O1:
+            member = 0
+
+        decoded_input = O1()
+        decoded_input.member = O2()
+        decoded_input.member.member = decoded_input
+
+        with pytest.raises(OverflowError, match="Maximum recursion level reached"):
+            ujson.ujson_dumps(decoded_input)
+
+    def test_decode_jibberish(self):
+        jibberish = "fdsa sda v9sa fdsa"
+        msg = "Unexpected character found when decoding 'false'"
+        with pytest.raises(ValueError, match=msg):
+            ujson.ujson_loads(jibberish)
+
+    @pytest.mark.parametrize(
+        "broken_json",
+        [
+            "[",  # Broken array start.
+            "{",  # Broken object start.
+            "]",  # Broken array end.
+            "}",  # Broken object end.
+        ],
+    )
+    def test_decode_broken_json(self, broken_json):
+        msg = "Expected object or value"
+        with pytest.raises(ValueError, match=msg):
+            ujson.ujson_loads(broken_json)
+
+    @pytest.mark.parametrize("too_big_char", ["[", "{"])
+    def test_decode_depth_too_big(self, too_big_char):
+        with pytest.raises(ValueError, match="Reached object decoding depth limit"):
+            ujson.ujson_loads(too_big_char * (1024 * 1024))
+
+    @pytest.mark.parametrize(
+        "bad_string",
+        [
+            '"TESTING',  # Unterminated.
+            '"TESTING\\"',  # Unterminated escape.
+            "tru",  # Broken True.
+            "fa",  # Broken False.
+            "n",  # Broken None.
+        ],
+    )
+    def test_decode_bad_string(self, bad_string):
+        msg = (
+            "Unexpected character found when decoding|"
+            "Unmatched ''\"' when when decoding 'string'"
+        )
+        with pytest.raises(ValueError, match=msg):
+            ujson.ujson_loads(bad_string)
+
+    @pytest.mark.parametrize(
+        "broken_json, err_msg",
+        [
+            (
+                '{{1337:""}}',
+                "Key name of object must be 'string' when decoding 'object'",
+            ),
+            ('{{"key":"}', "Unmatched ''\"' when when decoding 'string'"),
+            ("[[[true", "Unexpected character found when decoding array value (2)"),
+        ],
+    )
+    def test_decode_broken_json_leak(self, broken_json, err_msg):
+        for _ in range(1000):
+            with pytest.raises(ValueError, match=re.escape(err_msg)):
+                ujson.ujson_loads(broken_json)
+
+    @pytest.mark.parametrize(
+        "invalid_dict",
+        [
+            "{{{{31337}}}}",  # No key.
+            '{{{{"key":}}}}',  # No value.
+            '{{{{"key"}}}}',  # No colon or value.
+        ],
+    )
+    def test_decode_invalid_dict(self, invalid_dict):
+        msg = (
+            "Key name of object must be 'string' when decoding 'object'|"
+            "No ':' found when decoding object value|"
+            "Expected object or value"
+        )
+        with pytest.raises(ValueError, match=msg):
+            ujson.ujson_loads(invalid_dict)
+
+    @pytest.mark.parametrize(
+        "numeric_int_as_str", ["31337", "-31337"]  # Should work with negatives.
+    )
+    def test_decode_numeric_int(self, numeric_int_as_str):
+        assert int(numeric_int_as_str) == ujson.ujson_loads(numeric_int_as_str)
+
+    def test_encode_null_character(self):
+        wrapped_input = "31337 \x00 1337"
+        output = ujson.ujson_dumps(wrapped_input)
+
+        assert wrapped_input == json.loads(output)
+        assert output == json.dumps(wrapped_input)
+        assert wrapped_input == ujson.ujson_loads(output)
+
+        alone_input = "\x00"
+        output = ujson.ujson_dumps(alone_input)
+
+        assert alone_input == json.loads(output)
+        assert output == json.dumps(alone_input)
+        assert alone_input == ujson.ujson_loads(output)
+        assert '"  \\u0000\\r\\n "' == ujson.ujson_dumps("  \u0000\r\n ")
+
+    def test_decode_null_character(self):
+        wrapped_input = '"31337 \\u0000 31337"'
+        assert ujson.ujson_loads(wrapped_input) == json.loads(wrapped_input)
+
+    def test_encode_list_long_conversion(self):
+        long_input = [
+            9223372036854775807,
+            9223372036854775807,
+            9223372036854775807,
+            9223372036854775807,
+            9223372036854775807,
+            9223372036854775807,
+        ]
+        output = ujson.ujson_dumps(long_input)
+
+        assert long_input == json.loads(output)
+        assert long_input == ujson.ujson_loads(output)
+
+    @pytest.mark.parametrize("long_input", [9223372036854775807, 18446744073709551615])
+    def test_encode_long_conversion(self, long_input):
+        output = ujson.ujson_dumps(long_input)
+
+        assert long_input == json.loads(output)
+        assert output == json.dumps(long_input)
+        assert long_input == ujson.ujson_loads(output)
+
+    @pytest.mark.parametrize("bigNum", [2**64, -(2**63) - 1])
+    def test_dumps_ints_larger_than_maxsize(self, bigNum):
+        encoding = ujson.ujson_dumps(bigNum)
+        assert str(bigNum) == encoding
+
+        with pytest.raises(
+            ValueError,
+            match="Value is too big|Value is too small",
+        ):
+            assert ujson.ujson_loads(encoding) == bigNum
+
+    @pytest.mark.parametrize(
+        "int_exp", ["1337E40", "1.337E40", "1337E+9", "1.337e+40", "1.337E-4"]
+    )
+    def test_decode_numeric_int_exp(self, int_exp):
+        assert ujson.ujson_loads(int_exp) == json.loads(int_exp)
+
+    def test_loads_non_str_bytes_raises(self):
+        msg = "a bytes-like object is required, not 'NoneType'"
+        with pytest.raises(TypeError, match=msg):
+            ujson.ujson_loads(None)
+
+    @pytest.mark.parametrize("val", [3590016419, 2**31, 2**32, (2**32) - 1])
+    def test_decode_number_with_32bit_sign_bit(self, val):
+        # Test that numbers that fit within 32 bits but would have the
+        # sign bit set (2**31 <= x < 2**32) are decoded properly.
+        doc = f'{{"id": {val}}}'
+        assert ujson.ujson_loads(doc)["id"] == val
+
+    def test_encode_big_escape(self):
+        # Make sure no Exception is raised.
+        for _ in range(10):
+            base = "\u00e5".encode()
+            escape_input = base * 1024 * 1024 * 2
+            ujson.ujson_dumps(escape_input)
+
+    def test_decode_big_escape(self):
+        # Make sure no Exception is raised.
+        for _ in range(10):
+            base = "\u00e5".encode()
+            quote = b'"'
+
+            escape_input = quote + (base * 1024 * 1024 * 2) + quote
+            ujson.ujson_loads(escape_input)
+
+    def test_to_dict(self):
+        d = {"key": 31337}
+
+        class DictTest:
+            def toDict(self):
+                return d
+
+        o = DictTest()
+        output = ujson.ujson_dumps(o)
+
+        dec = ujson.ujson_loads(output)
+        assert dec == d
+
+    def test_default_handler(self):
+        class _TestObject:
+            def __init__(self, val) -> None:
+                self.val = val
+
+            @property
+            def recursive_attr(self):
+                return _TestObject("recursive_attr")
+
+            def __str__(self) -> str:
+                return str(self.val)
+
+        msg = "Maximum recursion level reached"
+        with pytest.raises(OverflowError, match=msg):
+            ujson.ujson_dumps(_TestObject("foo"))
+        assert '"foo"' == ujson.ujson_dumps(_TestObject("foo"), default_handler=str)
+
+        def my_handler(_):
+            return "foobar"
+
+        assert '"foobar"' == ujson.ujson_dumps(
+            _TestObject("foo"), default_handler=my_handler
+        )
+
+        def my_handler_raises(_):
+            raise TypeError("I raise for anything")
+
+        with pytest.raises(TypeError, match="I raise for anything"):
+            ujson.ujson_dumps(_TestObject("foo"), default_handler=my_handler_raises)
+
+        def my_int_handler(_):
+            return 42
+
+        assert (
+            ujson.ujson_loads(
+                ujson.ujson_dumps(_TestObject("foo"), default_handler=my_int_handler)
+            )
+            == 42
+        )
+
+        def my_obj_handler(_):
+            return datetime.datetime(2013, 2, 3)
+
+        assert ujson.ujson_loads(
+            ujson.ujson_dumps(datetime.datetime(2013, 2, 3))
+        ) == ujson.ujson_loads(
+            ujson.ujson_dumps(_TestObject("foo"), default_handler=my_obj_handler)
+        )
+
+        obj_list = [_TestObject("foo"), _TestObject("bar")]
+        assert json.loads(json.dumps(obj_list, default=str)) == ujson.ujson_loads(
+            ujson.ujson_dumps(obj_list, default_handler=str)
+        )
+
+    def test_encode_object(self):
+        class _TestObject:
+            def __init__(self, a, b, _c, d) -> None:
+                self.a = a
+                self.b = b
+                self._c = _c
+                self.d = d
+
+            def e(self):
+                return 5
+
+        # JSON keys should be all non-callable non-underscore attributes, see GH-42768
+        test_object = _TestObject(a=1, b=2, _c=3, d=4)
+        assert ujson.ujson_loads(ujson.ujson_dumps(test_object)) == {
+            "a": 1,
+            "b": 2,
+            "d": 4,
+        }
+
+    def test_ujson__name__(self):
+        # GH 52898
+        assert ujson.__name__ == "pandas._libs.json"
+
+
+class TestNumpyJSONTests:
+    @pytest.mark.parametrize("bool_input", [True, False])
+    def test_bool(self, bool_input):
+        b = bool(bool_input)
+        assert ujson.ujson_loads(ujson.ujson_dumps(b)) == b
+
+    def test_bool_array(self):
+        bool_array = np.array(
+            [True, False, True, True, False, True, False, False], dtype=bool
+        )
+        output = np.array(ujson.ujson_loads(ujson.ujson_dumps(bool_array)), dtype=bool)
+        tm.assert_numpy_array_equal(bool_array, output)
+
+    def test_int(self, any_int_numpy_dtype):
+        klass = np.dtype(any_int_numpy_dtype).type
+        num = klass(1)
+
+        assert klass(ujson.ujson_loads(ujson.ujson_dumps(num))) == num
+
+    def test_int_array(self, any_int_numpy_dtype):
+        arr = np.arange(100, dtype=int)
+        arr_input = arr.astype(any_int_numpy_dtype)
+
+        arr_output = np.array(
+            ujson.ujson_loads(ujson.ujson_dumps(arr_input)), dtype=any_int_numpy_dtype
+        )
+        tm.assert_numpy_array_equal(arr_input, arr_output)
+
+    def test_int_max(self, any_int_numpy_dtype):
+        if any_int_numpy_dtype in ("int64", "uint64") and not IS64:
+            pytest.skip("Cannot test 64-bit integer on 32-bit platform")
+
+        klass = np.dtype(any_int_numpy_dtype).type
+
+        # uint64 max will always overflow,
+        # as it's encoded to signed.
+        if any_int_numpy_dtype == "uint64":
+            num = np.iinfo("int64").max
+        else:
+            num = np.iinfo(any_int_numpy_dtype).max
+
+        assert klass(ujson.ujson_loads(ujson.ujson_dumps(num))) == num
+
+    def test_float(self, float_numpy_dtype):
+        klass = np.dtype(float_numpy_dtype).type
+        num = klass(256.2013)
+
+        assert klass(ujson.ujson_loads(ujson.ujson_dumps(num))) == num
+
+    def test_float_array(self, float_numpy_dtype):
+        arr = np.arange(12.5, 185.72, 1.7322, dtype=float)
+        float_input = arr.astype(float_numpy_dtype)
+
+        float_output = np.array(
+            ujson.ujson_loads(ujson.ujson_dumps(float_input, double_precision=15)),
+            dtype=float_numpy_dtype,
+        )
+        tm.assert_almost_equal(float_input, float_output)
+
+    def test_float_max(self, float_numpy_dtype):
+        klass = np.dtype(float_numpy_dtype).type
+        num = klass(np.finfo(float_numpy_dtype).max / 10)
+
+        tm.assert_almost_equal(
+            klass(ujson.ujson_loads(ujson.ujson_dumps(num, double_precision=15))), num
+        )
+
+    def test_array_basic(self):
+        arr = np.arange(96)
+        arr = arr.reshape((2, 2, 2, 2, 3, 2))
+
+        tm.assert_numpy_array_equal(
+            np.array(ujson.ujson_loads(ujson.ujson_dumps(arr))), arr
+        )
+
+    @pytest.mark.parametrize("shape", [(10, 10), (5, 5, 4), (100, 1)])
+    def test_array_reshaped(self, shape):
+        arr = np.arange(100)
+        arr = arr.reshape(shape)
+
+        tm.assert_numpy_array_equal(
+            np.array(ujson.ujson_loads(ujson.ujson_dumps(arr))), arr
+        )
+
+    def test_array_list(self):
+        arr_list = [
+            "a",
+            [],
+            {},
+            {},
+            [],
+            42,
+            97.8,
+            ["a", "b"],
+            {"key": "val"},
+        ]
+        arr = np.array(arr_list, dtype=object)
+        result = np.array(ujson.ujson_loads(ujson.ujson_dumps(arr)), dtype=object)
+        tm.assert_numpy_array_equal(result, arr)
+
+    def test_array_float(self):
+        dtype = np.float32
+
+        arr = np.arange(100.202, 200.202, 1, dtype=dtype)
+        arr = arr.reshape((5, 5, 4))
+
+        arr_out = np.array(ujson.ujson_loads(ujson.ujson_dumps(arr)), dtype=dtype)
+        tm.assert_almost_equal(arr, arr_out)
+
+    def test_0d_array(self):
+        # gh-18878
+        msg = re.escape(
+            "array(1) (numpy-scalar) is not JSON serializable at the moment"
+        )
+        with pytest.raises(TypeError, match=msg):
+            ujson.ujson_dumps(np.array(1))
+
+    def test_array_long_double(self):
+        msg = re.compile(
+            "1234.5.* \\(numpy-scalar\\) is not JSON serializable at the moment"
+        )
+        with pytest.raises(TypeError, match=msg):
+            ujson.ujson_dumps(np.longdouble(1234.5))
+
+
+class TestPandasJSONTests:
+    def test_dataframe(self, orient):
+        dtype = np.int64
+
+        df = DataFrame(
+            [[1, 2, 3], [4, 5, 6]],
+            index=["a", "b"],
+            columns=["x", "y", "z"],
+            dtype=dtype,
+        )
+        encode_kwargs = {} if orient is None else {"orient": orient}
+        assert (df.dtypes == dtype).all()
+
+        output = ujson.ujson_loads(ujson.ujson_dumps(df, **encode_kwargs))
+        assert (df.dtypes == dtype).all()
+
+        # Ensure proper DataFrame initialization.
+        if orient == "split":
+            dec = _clean_dict(output)
+            output = DataFrame(**dec)
+        else:
+            output = DataFrame(output)
+
+        # Corrections to enable DataFrame comparison.
+        if orient == "values":
+            df.columns = [0, 1, 2]
+            df.index = [0, 1]
+        elif orient == "records":
+            df.index = [0, 1]
+        elif orient == "index":
+            df = df.transpose()
+
+        assert (df.dtypes == dtype).all()
+        tm.assert_frame_equal(output, df)
+
+    def test_dataframe_nested(self, orient):
+        df = DataFrame(
+            [[1, 2, 3], [4, 5, 6]], index=["a", "b"], columns=["x", "y", "z"]
+        )
+
+        nested = {"df1": df, "df2": df.copy()}
+        kwargs = {} if orient is None else {"orient": orient}
+
+        exp = {
+            "df1": ujson.ujson_loads(ujson.ujson_dumps(df, **kwargs)),
+            "df2": ujson.ujson_loads(ujson.ujson_dumps(df, **kwargs)),
+        }
+        assert ujson.ujson_loads(ujson.ujson_dumps(nested, **kwargs)) == exp
+
+    def test_series(self, orient):
+        dtype = np.int64
+        s = Series(
+            [10, 20, 30, 40, 50, 60],
+            name="series",
+            index=[6, 7, 8, 9, 10, 15],
+            dtype=dtype,
+        ).sort_values()
+        assert s.dtype == dtype
+
+        encode_kwargs = {} if orient is None else {"orient": orient}
+
+        output = ujson.ujson_loads(ujson.ujson_dumps(s, **encode_kwargs))
+        assert s.dtype == dtype
+
+        if orient == "split":
+            dec = _clean_dict(output)
+            output = Series(**dec)
+        else:
+            output = Series(output)
+
+        if orient in (None, "index"):
+            s.name = None
+            output = output.sort_values()
+            s.index = ["6", "7", "8", "9", "10", "15"]
+        elif orient in ("records", "values"):
+            s.name = None
+            s.index = [0, 1, 2, 3, 4, 5]
+
+        assert s.dtype == dtype
+        tm.assert_series_equal(output, s)
+
+    def test_series_nested(self, orient):
+        s = Series(
+            [10, 20, 30, 40, 50, 60], name="series", index=[6, 7, 8, 9, 10, 15]
+        ).sort_values()
+        nested = {"s1": s, "s2": s.copy()}
+        kwargs = {} if orient is None else {"orient": orient}
+
+        exp = {
+            "s1": ujson.ujson_loads(ujson.ujson_dumps(s, **kwargs)),
+            "s2": ujson.ujson_loads(ujson.ujson_dumps(s, **kwargs)),
+        }
+        assert ujson.ujson_loads(ujson.ujson_dumps(nested, **kwargs)) == exp
+
+    def test_index(self):
+        i = Index([23, 45, 18, 98, 43, 11], name="index")
+
+        # Column indexed.
+        output = Index(ujson.ujson_loads(ujson.ujson_dumps(i)), name="index")
+        tm.assert_index_equal(i, output)
+
+        dec = _clean_dict(ujson.ujson_loads(ujson.ujson_dumps(i, orient="split")))
+        output = Index(**dec)
+
+        tm.assert_index_equal(i, output)
+        assert i.name == output.name
+
+        tm.assert_index_equal(i, output)
+        assert i.name == output.name
+
+        output = Index(
+            ujson.ujson_loads(ujson.ujson_dumps(i, orient="values")), name="index"
+        )
+        tm.assert_index_equal(i, output)
+
+        output = Index(
+            ujson.ujson_loads(ujson.ujson_dumps(i, orient="records")), name="index"
+        )
+        tm.assert_index_equal(i, output)
+
+        output = Index(
+            ujson.ujson_loads(ujson.ujson_dumps(i, orient="index")), name="index"
+        )
+        tm.assert_index_equal(i, output)
+
+    def test_datetime_index(self):
+        date_unit = "ns"
+
+        # freq doesn't round-trip
+        rng = DatetimeIndex(list(date_range("1/1/2000", periods=20)), freq=None)
+        encoded = ujson.ujson_dumps(rng, date_unit=date_unit)
+
+        decoded = DatetimeIndex(np.array(ujson.ujson_loads(encoded)))
+        tm.assert_index_equal(rng, decoded)
+
+        ts = Series(np.random.default_rng(2).standard_normal(len(rng)), index=rng)
+        decoded = Series(ujson.ujson_loads(ujson.ujson_dumps(ts, date_unit=date_unit)))
+
+        idx_values = decoded.index.values.astype(np.int64)
+        decoded.index = DatetimeIndex(idx_values)
+        tm.assert_series_equal(ts, decoded)
+
+    @pytest.mark.parametrize(
+        "invalid_arr",
+        [
+            "[31337,]",  # Trailing comma.
+            "[,31337]",  # Leading comma.
+            "[]]",  # Unmatched bracket.
+            "[,]",  # Only comma.
+        ],
+    )
+    def test_decode_invalid_array(self, invalid_arr):
+        msg = (
+            "Expected object or value|Trailing data|"
+            "Unexpected character found when decoding array value"
+        )
+        with pytest.raises(ValueError, match=msg):
+            ujson.ujson_loads(invalid_arr)
+
+    @pytest.mark.parametrize("arr", [[], [31337]])
+    def test_decode_array(self, arr):
+        assert arr == ujson.ujson_loads(str(arr))
+
+    @pytest.mark.parametrize("extreme_num", [9223372036854775807, -9223372036854775808])
+    def test_decode_extreme_numbers(self, extreme_num):
+        assert extreme_num == ujson.ujson_loads(str(extreme_num))
+
+    @pytest.mark.parametrize("too_extreme_num", [f"{2**64}", f"{-2**63-1}"])
+    def test_decode_too_extreme_numbers(self, too_extreme_num):
+        with pytest.raises(
+            ValueError,
+            match="Value is too big|Value is too small",
+        ):
+            ujson.ujson_loads(too_extreme_num)
+
+    def test_decode_with_trailing_whitespaces(self):
+        assert {} == ujson.ujson_loads("{}\n\t ")
+
+    def test_decode_with_trailing_non_whitespaces(self):
+        with pytest.raises(ValueError, match="Trailing data"):
+            ujson.ujson_loads("{}\n\t a")
+
+    @pytest.mark.parametrize("value", [f"{2**64}", f"{-2**63-1}"])
+    def test_decode_array_with_big_int(self, value):
+        with pytest.raises(
+            ValueError,
+            match="Value is too big|Value is too small",
+        ):
+            ujson.ujson_loads(value)
+
+    @pytest.mark.parametrize(
+        "float_number",
+        [
+            1.1234567893,
+            1.234567893,
+            1.34567893,
+            1.4567893,
+            1.567893,
+            1.67893,
+            1.7893,
+            1.893,
+            1.3,
+        ],
+    )
+    @pytest.mark.parametrize("sign", [-1, 1])
+    def test_decode_floating_point(self, sign, float_number):
+        float_number *= sign
+        tm.assert_almost_equal(
+            float_number, ujson.ujson_loads(str(float_number)), rtol=1e-15
+        )
+
+    def test_encode_big_set(self):
+        s = set()
+
+        for x in range(100000):
+            s.add(x)
+
+        # Make sure no Exception is raised.
+        ujson.ujson_dumps(s)
+
+    def test_encode_empty_set(self):
+        assert "[]" == ujson.ujson_dumps(set())
+
+    def test_encode_set(self):
+        s = {1, 2, 3, 4, 5, 6, 7, 8, 9}
+        enc = ujson.ujson_dumps(s)
+        dec = ujson.ujson_loads(enc)
+
+        for v in dec:
+            assert v in s
+
+    @pytest.mark.parametrize(
+        "td",
+        [
+            Timedelta(days=366),
+            Timedelta(days=-1),
+            Timedelta(hours=13, minutes=5, seconds=5),
+            Timedelta(hours=13, minutes=20, seconds=30),
+            Timedelta(days=-1, nanoseconds=5),
+            Timedelta(nanoseconds=1),
+            Timedelta(microseconds=1, nanoseconds=1),
+            Timedelta(milliseconds=1, microseconds=1, nanoseconds=1),
+            Timedelta(milliseconds=999, microseconds=999, nanoseconds=999),
+        ],
+    )
+    def test_encode_timedelta_iso(self, td):
+        # GH 28256
+        result = ujson.ujson_dumps(td, iso_dates=True)
+        expected = f'"{td.isoformat()}"'
+
+        assert result == expected
+
+    def test_encode_periodindex(self):
+        # GH 46683
+        p = PeriodIndex(["2022-04-06", "2022-04-07"], freq="D")
+        df = DataFrame(index=p)
+        assert df.to_json() == "{}"