Add files using upload-large-folder tool

.gitattributes

@@ -197,3 +197,4 @@ llmeval-env/lib/python3.10/site-packages/pandas/_libs/algos.cpython-310-x86_64-l
 llmeval-env/lib/python3.10/site-packages/pandas/_libs/groupby.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 llmeval-env/lib/python3.10/site-packages/pandas/_libs/tslibs/offsets.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 llmeval-env/lib/python3.10/site-packages/pandas/_libs/hashtable.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+llmeval-env/lib/python3.10/site-packages/nvidia/cublas/lib/libcublasLt.so.12 filter=lfs diff=lfs merge=lfs -text

llmeval-env/lib/python3.10/site-packages/nvidia/cublas/lib/libcublasLt.so.12

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

llmeval-env/lib/python3.10/site-packages/pandas/tests/io/json/conftest.py

@@ -0,0 +1,9 @@
+import pytest
+
+
+@pytest.fixture(params=["split", "records", "index", "columns", "values"])
+def orient(request):
+    """
+    Fixture for orients excluding the table format.
+    """
+    return request.param

llmeval-env/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)

llmeval-env/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"))

llmeval-env/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)

llmeval-env/lib/python3.10/site-packages/pandas/tests/io/json/test_json_table_schema_ext_dtype.py

@@ -0,0 +1,317 @@
+"""Tests for ExtensionDtype Table Schema integration."""
+
+from collections import OrderedDict
+import datetime as dt
+import decimal
+from io import StringIO
+import json
+
+import pytest
+
+from pandas import (
+    NA,
+    DataFrame,
+    Index,
+    array,
+    read_json,
+)
+import pandas._testing as tm
+from pandas.core.arrays.integer import Int64Dtype
+from pandas.core.arrays.string_ import StringDtype
+from pandas.core.series import Series
+from pandas.tests.extension.date import (
+    DateArray,
+    DateDtype,
+)
+from pandas.tests.extension.decimal.array import (
+    DecimalArray,
+    DecimalDtype,
+)
+
+from pandas.io.json._table_schema import (
+    as_json_table_type,
+    build_table_schema,
+)
+
+
+class TestBuildSchema:
+    def test_build_table_schema(self):
+        df = DataFrame(
+            {
+                "A": DateArray([dt.date(2021, 10, 10)]),
+                "B": DecimalArray([decimal.Decimal(10)]),
+                "C": array(["pandas"], dtype="string"),
+                "D": array([10], dtype="Int64"),
+            }
+        )
+        result = build_table_schema(df, version=False)
+        expected = {
+            "fields": [
+                {"name": "index", "type": "integer"},
+                {"name": "A", "type": "any", "extDtype": "DateDtype"},
+                {"name": "B", "type": "number", "extDtype": "decimal"},
+                {"name": "C", "type": "any", "extDtype": "string"},
+                {"name": "D", "type": "integer", "extDtype": "Int64"},
+            ],
+            "primaryKey": ["index"],
+        }
+        assert result == expected
+        result = build_table_schema(df)
+        assert "pandas_version" in result
+
+
+class TestTableSchemaType:
+    @pytest.mark.parametrize(
+        "date_data",
+        [
+            DateArray([dt.date(2021, 10, 10)]),
+            DateArray(dt.date(2021, 10, 10)),
+            Series(DateArray(dt.date(2021, 10, 10))),
+        ],
+    )
+    def test_as_json_table_type_ext_date_array_dtype(self, date_data):
+        assert as_json_table_type(date_data.dtype) == "any"
+
+    def test_as_json_table_type_ext_date_dtype(self):
+        assert as_json_table_type(DateDtype()) == "any"
+
+    @pytest.mark.parametrize(
+        "decimal_data",
+        [
+            DecimalArray([decimal.Decimal(10)]),
+            Series(DecimalArray([decimal.Decimal(10)])),
+        ],
+    )
+    def test_as_json_table_type_ext_decimal_array_dtype(self, decimal_data):
+        assert as_json_table_type(decimal_data.dtype) == "number"
+
+    def test_as_json_table_type_ext_decimal_dtype(self):
+        assert as_json_table_type(DecimalDtype()) == "number"
+
+    @pytest.mark.parametrize(
+        "string_data",
+        [
+            array(["pandas"], dtype="string"),
+            Series(array(["pandas"], dtype="string")),
+        ],
+    )
+    def test_as_json_table_type_ext_string_array_dtype(self, string_data):
+        assert as_json_table_type(string_data.dtype) == "any"
+
+    def test_as_json_table_type_ext_string_dtype(self):
+        assert as_json_table_type(StringDtype()) == "any"
+
+    @pytest.mark.parametrize(
+        "integer_data",
+        [
+            array([10], dtype="Int64"),
+            Series(array([10], dtype="Int64")),
+        ],
+    )
+    def test_as_json_table_type_ext_integer_array_dtype(self, integer_data):
+        assert as_json_table_type(integer_data.dtype) == "integer"
+
+    def test_as_json_table_type_ext_integer_dtype(self):
+        assert as_json_table_type(Int64Dtype()) == "integer"
+
+
+class TestTableOrient:
+    @pytest.fixture
+    def da(self):
+        return DateArray([dt.date(2021, 10, 10)])
+
+    @pytest.fixture
+    def dc(self):
+        return DecimalArray([decimal.Decimal(10)])
+
+    @pytest.fixture
+    def sa(self):
+        return array(["pandas"], dtype="string")
+
+    @pytest.fixture
+    def ia(self):
+        return array([10], dtype="Int64")
+
+    @pytest.fixture
+    def df(self, da, dc, sa, ia):
+        return DataFrame(
+            {
+                "A": da,
+                "B": dc,
+                "C": sa,
+                "D": ia,
+            }
+        )
+
+    def test_build_date_series(self, da):
+        s = Series(da, 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": "any", "extDtype": "DateDtype"},
+        ]
+
+        schema = {"fields": fields, "primaryKey": ["id"]}
+
+        expected = OrderedDict(
+            [
+                ("schema", schema),
+                ("data", [OrderedDict([("id", 0), ("a", "2021-10-10T00:00:00.000")])]),
+            ]
+        )
+
+        assert result == expected
+
+    def test_build_decimal_series(self, dc):
+        s = Series(dc, 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": "number", "extDtype": "decimal"},
+        ]
+
+        schema = {"fields": fields, "primaryKey": ["id"]}
+
+        expected = OrderedDict(
+            [
+                ("schema", schema),
+                ("data", [OrderedDict([("id", 0), ("a", 10.0)])]),
+            ]
+        )
+
+        assert result == expected
+
+    def test_build_string_series(self, sa):
+        s = Series(sa, 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": "any", "extDtype": "string"},
+        ]
+
+        schema = {"fields": fields, "primaryKey": ["id"]}
+
+        expected = OrderedDict(
+            [
+                ("schema", schema),
+                ("data", [OrderedDict([("id", 0), ("a", "pandas")])]),
+            ]
+        )
+
+        assert result == expected
+
+    def test_build_int64_series(self, ia):
+        s = Series(ia, 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", "extDtype": "Int64"},
+        ]
+
+        schema = {"fields": fields, "primaryKey": ["id"]}
+
+        expected = OrderedDict(
+            [
+                ("schema", schema),
+                ("data", [OrderedDict([("id", 0), ("a", 10)])]),
+            ]
+        )
+
+        assert result == expected
+
+    def test_to_json(self, df):
+        df = df.copy()
+        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 = [
+            OrderedDict({"name": "idx", "type": "integer"}),
+            OrderedDict({"name": "A", "type": "any", "extDtype": "DateDtype"}),
+            OrderedDict({"name": "B", "type": "number", "extDtype": "decimal"}),
+            OrderedDict({"name": "C", "type": "any", "extDtype": "string"}),
+            OrderedDict({"name": "D", "type": "integer", "extDtype": "Int64"}),
+        ]
+
+        schema = OrderedDict({"fields": fields, "primaryKey": ["idx"]})
+        data = [
+            OrderedDict(
+                [
+                    ("idx", 0),
+                    ("A", "2021-10-10T00:00:00.000"),
+                    ("B", 10.0),
+                    ("C", "pandas"),
+                    ("D", 10),
+                ]
+            )
+        ]
+        expected = OrderedDict([("schema", schema), ("data", data)])
+
+        assert result == expected
+
+    def test_json_ext_dtype_reading_roundtrip(self):
+        # GH#40255
+        df = DataFrame(
+            {
+                "a": Series([2, NA], dtype="Int64"),
+                "b": Series([1.5, NA], dtype="Float64"),
+                "c": Series([True, NA], dtype="boolean"),
+            },
+            index=Index([1, NA], dtype="Int64"),
+        )
+        expected = df.copy()
+        data_json = df.to_json(orient="table", indent=4)
+        result = read_json(StringIO(data_json), orient="table")
+        tm.assert_frame_equal(result, expected)
+
+    def test_json_ext_dtype_reading(self):
+        # GH#40255
+        data_json = """{
+            "schema":{
+                "fields":[
+                    {
+                        "name":"a",
+                        "type":"integer",
+                        "extDtype":"Int64"
+                    }
+                ],
+            },
+            "data":[
+                {
+                    "a":2
+                },
+                {
+                    "a":null
+                }
+            ]
+        }"""
+        result = read_json(StringIO(data_json), orient="table")
+        expected = DataFrame({"a": Series([2, NA], dtype="Int64")})
+        tm.assert_frame_equal(result, expected)

llmeval-env/lib/python3.10/site-packages/pandas/tests/io/json/test_normalize.py

@@ -0,0 +1,907 @@
+import json
+
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    Index,
+    Series,
+    json_normalize,
+)
+import pandas._testing as tm
+
+from pandas.io.json._normalize import nested_to_record
+
+
+@pytest.fixture
+def deep_nested():
+    # deeply nested data
+    return [
+        {
+            "country": "USA",
+            "states": [
+                {
+                    "name": "California",
+                    "cities": [
+                        {"name": "San Francisco", "pop": 12345},
+                        {"name": "Los Angeles", "pop": 12346},
+                    ],
+                },
+                {
+                    "name": "Ohio",
+                    "cities": [
+                        {"name": "Columbus", "pop": 1234},
+                        {"name": "Cleveland", "pop": 1236},
+                    ],
+                },
+            ],
+        },
+        {
+            "country": "Germany",
+            "states": [
+                {"name": "Bayern", "cities": [{"name": "Munich", "pop": 12347}]},
+                {
+                    "name": "Nordrhein-Westfalen",
+                    "cities": [
+                        {"name": "Duesseldorf", "pop": 1238},
+                        {"name": "Koeln", "pop": 1239},
+                    ],
+                },
+            ],
+        },
+    ]
+
+
+@pytest.fixture
+def state_data():
+    return [
+        {
+            "counties": [
+                {"name": "Dade", "population": 12345},
+                {"name": "Broward", "population": 40000},
+                {"name": "Palm Beach", "population": 60000},
+            ],
+            "info": {"governor": "Rick Scott"},
+            "shortname": "FL",
+            "state": "Florida",
+        },
+        {
+            "counties": [
+                {"name": "Summit", "population": 1234},
+                {"name": "Cuyahoga", "population": 1337},
+            ],
+            "info": {"governor": "John Kasich"},
+            "shortname": "OH",
+            "state": "Ohio",
+        },
+    ]
+
+
+@pytest.fixture
+def author_missing_data():
+    return [
+        {"info": None},
+        {
+            "info": {"created_at": "11/08/1993", "last_updated": "26/05/2012"},
+            "author_name": {"first": "Jane", "last_name": "Doe"},
+        },
+    ]
+
+
+@pytest.fixture
+def missing_metadata():
+    return [
+        {
+            "name": "Alice",
+            "addresses": [
+                {
+                    "number": 9562,
+                    "street": "Morris St.",
+                    "city": "Massillon",
+                    "state": "OH",
+                    "zip": 44646,
+                }
+            ],
+            "previous_residences": {"cities": [{"city_name": "Foo York City"}]},
+        },
+        {
+            "addresses": [
+                {
+                    "number": 8449,
+                    "street": "Spring St.",
+                    "city": "Elizabethton",
+                    "state": "TN",
+                    "zip": 37643,
+                }
+            ],
+            "previous_residences": {"cities": [{"city_name": "Barmingham"}]},
+        },
+    ]
+
+
+@pytest.fixture
+def max_level_test_input_data():
+    """
+    input data to test json_normalize with max_level param
+    """
+    return [
+        {
+            "CreatedBy": {"Name": "User001"},
+            "Lookup": {
+                "TextField": "Some text",
+                "UserField": {"Id": "ID001", "Name": "Name001"},
+            },
+            "Image": {"a": "b"},
+        }
+    ]
+
+
+class TestJSONNormalize:
+    def test_simple_records(self):
+        recs = [
+            {"a": 1, "b": 2, "c": 3},
+            {"a": 4, "b": 5, "c": 6},
+            {"a": 7, "b": 8, "c": 9},
+            {"a": 10, "b": 11, "c": 12},
+        ]
+
+        result = json_normalize(recs)
+        expected = DataFrame(recs)
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_simple_normalize(self, state_data):
+        result = json_normalize(state_data[0], "counties")
+        expected = DataFrame(state_data[0]["counties"])
+        tm.assert_frame_equal(result, expected)
+
+        result = json_normalize(state_data, "counties")
+
+        expected = []
+        for rec in state_data:
+            expected.extend(rec["counties"])
+        expected = DataFrame(expected)
+
+        tm.assert_frame_equal(result, expected)
+
+        result = json_normalize(state_data, "counties", meta="state")
+        expected["state"] = np.array(["Florida", "Ohio"]).repeat([3, 2])
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_fields_list_type_normalize(self):
+        parse_metadata_fields_list_type = [
+            {"values": [1, 2, 3], "metadata": {"listdata": [1, 2]}}
+        ]
+        result = json_normalize(
+            parse_metadata_fields_list_type,
+            record_path=["values"],
+            meta=[["metadata", "listdata"]],
+        )
+        expected = DataFrame(
+            {0: [1, 2, 3], "metadata.listdata": [[1, 2], [1, 2], [1, 2]]}
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_empty_array(self):
+        result = json_normalize([])
+        expected = DataFrame()
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "data, record_path, exception_type",
+        [
+            ([{"a": 0}, {"a": 1}], None, None),
+            ({"a": [{"a": 0}, {"a": 1}]}, "a", None),
+            ('{"a": [{"a": 0}, {"a": 1}]}', None, NotImplementedError),
+            (None, None, NotImplementedError),
+        ],
+    )
+    def test_accepted_input(self, data, record_path, exception_type):
+        if exception_type is not None:
+            with pytest.raises(exception_type, match=""):
+                json_normalize(data, record_path=record_path)
+        else:
+            result = json_normalize(data, record_path=record_path)
+            expected = DataFrame([0, 1], columns=["a"])
+            tm.assert_frame_equal(result, expected)
+
+    def test_simple_normalize_with_separator(self, deep_nested):
+        # GH 14883
+        result = json_normalize({"A": {"A": 1, "B": 2}})
+        expected = DataFrame([[1, 2]], columns=["A.A", "A.B"])
+        tm.assert_frame_equal(result.reindex_like(expected), expected)
+
+        result = json_normalize({"A": {"A": 1, "B": 2}}, sep="_")
+        expected = DataFrame([[1, 2]], columns=["A_A", "A_B"])
+        tm.assert_frame_equal(result.reindex_like(expected), expected)
+
+        result = json_normalize({"A": {"A": 1, "B": 2}}, sep="\u03c3")
+        expected = DataFrame([[1, 2]], columns=["A\u03c3A", "A\u03c3B"])
+        tm.assert_frame_equal(result.reindex_like(expected), expected)
+
+        result = json_normalize(
+            deep_nested,
+            ["states", "cities"],
+            meta=["country", ["states", "name"]],
+            sep="_",
+        )
+        expected = Index(["name", "pop", "country", "states_name"]).sort_values()
+        assert result.columns.sort_values().equals(expected)
+
+    def test_normalize_with_multichar_separator(self):
+        # GH #43831
+        data = {"a": [1, 2], "b": {"b_1": 2, "b_2": (3, 4)}}
+        result = json_normalize(data, sep="__")
+        expected = DataFrame([[[1, 2], 2, (3, 4)]], columns=["a", "b__b_1", "b__b_2"])
+        tm.assert_frame_equal(result, expected)
+
+    def test_value_array_record_prefix(self):
+        # GH 21536
+        result = json_normalize({"A": [1, 2]}, "A", record_prefix="Prefix.")
+        expected = DataFrame([[1], [2]], columns=["Prefix.0"])
+        tm.assert_frame_equal(result, expected)
+
+    def test_nested_object_record_path(self):
+        # GH 22706
+        data = {
+            "state": "Florida",
+            "info": {
+                "governor": "Rick Scott",
+                "counties": [
+                    {"name": "Dade", "population": 12345},
+                    {"name": "Broward", "population": 40000},
+                    {"name": "Palm Beach", "population": 60000},
+                ],
+            },
+        }
+        result = json_normalize(data, record_path=["info", "counties"])
+        expected = DataFrame(
+            [["Dade", 12345], ["Broward", 40000], ["Palm Beach", 60000]],
+            columns=["name", "population"],
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_more_deeply_nested(self, deep_nested):
+        result = json_normalize(
+            deep_nested, ["states", "cities"], meta=["country", ["states", "name"]]
+        )
+        ex_data = {
+            "country": ["USA"] * 4 + ["Germany"] * 3,
+            "states.name": [
+                "California",
+                "California",
+                "Ohio",
+                "Ohio",
+                "Bayern",
+                "Nordrhein-Westfalen",
+                "Nordrhein-Westfalen",
+            ],
+            "name": [
+                "San Francisco",
+                "Los Angeles",
+                "Columbus",
+                "Cleveland",
+                "Munich",
+                "Duesseldorf",
+                "Koeln",
+            ],
+            "pop": [12345, 12346, 1234, 1236, 12347, 1238, 1239],
+        }
+
+        expected = DataFrame(ex_data, columns=result.columns)
+        tm.assert_frame_equal(result, expected)
+
+    def test_shallow_nested(self):
+        data = [
+            {
+                "state": "Florida",
+                "shortname": "FL",
+                "info": {"governor": "Rick Scott"},
+                "counties": [
+                    {"name": "Dade", "population": 12345},
+                    {"name": "Broward", "population": 40000},
+                    {"name": "Palm Beach", "population": 60000},
+                ],
+            },
+            {
+                "state": "Ohio",
+                "shortname": "OH",
+                "info": {"governor": "John Kasich"},
+                "counties": [
+                    {"name": "Summit", "population": 1234},
+                    {"name": "Cuyahoga", "population": 1337},
+                ],
+            },
+        ]
+
+        result = json_normalize(
+            data, "counties", ["state", "shortname", ["info", "governor"]]
+        )
+        ex_data = {
+            "name": ["Dade", "Broward", "Palm Beach", "Summit", "Cuyahoga"],
+            "state": ["Florida"] * 3 + ["Ohio"] * 2,
+            "shortname": ["FL", "FL", "FL", "OH", "OH"],
+            "info.governor": ["Rick Scott"] * 3 + ["John Kasich"] * 2,
+            "population": [12345, 40000, 60000, 1234, 1337],
+        }
+        expected = DataFrame(ex_data, columns=result.columns)
+        tm.assert_frame_equal(result, expected)
+
+    def test_nested_meta_path_with_nested_record_path(self, state_data):
+        # GH 27220
+        result = json_normalize(
+            data=state_data,
+            record_path=["counties"],
+            meta=["state", "shortname", ["info", "governor"]],
+            errors="ignore",
+        )
+
+        ex_data = {
+            "name": ["Dade", "Broward", "Palm Beach", "Summit", "Cuyahoga"],
+            "population": [12345, 40000, 60000, 1234, 1337],
+            "state": ["Florida"] * 3 + ["Ohio"] * 2,
+            "shortname": ["FL"] * 3 + ["OH"] * 2,
+            "info.governor": ["Rick Scott"] * 3 + ["John Kasich"] * 2,
+        }
+
+        expected = DataFrame(ex_data)
+        tm.assert_frame_equal(result, expected)
+
+    def test_meta_name_conflict(self):
+        data = [
+            {
+                "foo": "hello",
+                "bar": "there",
+                "data": [
+                    {"foo": "something", "bar": "else"},
+                    {"foo": "something2", "bar": "else2"},
+                ],
+            }
+        ]
+
+        msg = r"Conflicting metadata name (foo|bar), need distinguishing prefix"
+        with pytest.raises(ValueError, match=msg):
+            json_normalize(data, "data", meta=["foo", "bar"])
+
+        result = json_normalize(data, "data", meta=["foo", "bar"], meta_prefix="meta")
+
+        for val in ["metafoo", "metabar", "foo", "bar"]:
+            assert val in result
+
+    def test_meta_parameter_not_modified(self):
+        # GH 18610
+        data = [
+            {
+                "foo": "hello",
+                "bar": "there",
+                "data": [
+                    {"foo": "something", "bar": "else"},
+                    {"foo": "something2", "bar": "else2"},
+                ],
+            }
+        ]
+
+        COLUMNS = ["foo", "bar"]
+        result = json_normalize(data, "data", meta=COLUMNS, meta_prefix="meta")
+
+        assert COLUMNS == ["foo", "bar"]
+        for val in ["metafoo", "metabar", "foo", "bar"]:
+            assert val in result
+
+    def test_record_prefix(self, state_data):
+        result = json_normalize(state_data[0], "counties")
+        expected = DataFrame(state_data[0]["counties"])
+        tm.assert_frame_equal(result, expected)
+
+        result = json_normalize(
+            state_data, "counties", meta="state", record_prefix="county_"
+        )
+
+        expected = []
+        for rec in state_data:
+            expected.extend(rec["counties"])
+        expected = DataFrame(expected)
+        expected = expected.rename(columns=lambda x: "county_" + x)
+        expected["state"] = np.array(["Florida", "Ohio"]).repeat([3, 2])
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_non_ascii_key(self):
+        testjson = (
+            b'[{"\xc3\x9cnic\xc3\xb8de":0,"sub":{"A":1, "B":2}},'
+            b'{"\xc3\x9cnic\xc3\xb8de":1,"sub":{"A":3, "B":4}}]'
+        ).decode("utf8")
+
+        testdata = {
+            b"\xc3\x9cnic\xc3\xb8de".decode("utf8"): [0, 1],
+            "sub.A": [1, 3],
+            "sub.B": [2, 4],
+        }
+        expected = DataFrame(testdata)
+
+        result = json_normalize(json.loads(testjson))
+        tm.assert_frame_equal(result, expected)
+
+    def test_missing_field(self, author_missing_data):
+        # GH20030:
+        result = json_normalize(author_missing_data)
+        ex_data = [
+            {
+                "info": np.nan,
+                "info.created_at": np.nan,
+                "info.last_updated": np.nan,
+                "author_name.first": np.nan,
+                "author_name.last_name": np.nan,
+            },
+            {
+                "info": None,
+                "info.created_at": "11/08/1993",
+                "info.last_updated": "26/05/2012",
+                "author_name.first": "Jane",
+                "author_name.last_name": "Doe",
+            },
+        ]
+        expected = DataFrame(ex_data)
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "max_level,expected",
+        [
+            (
+                0,
+                [
+                    {
+                        "TextField": "Some text",
+                        "UserField": {"Id": "ID001", "Name": "Name001"},
+                        "CreatedBy": {"Name": "User001"},
+                        "Image": {"a": "b"},
+                    },
+                    {
+                        "TextField": "Some text",
+                        "UserField": {"Id": "ID001", "Name": "Name001"},
+                        "CreatedBy": {"Name": "User001"},
+                        "Image": {"a": "b"},
+                    },
+                ],
+            ),
+            (
+                1,
+                [
+                    {
+                        "TextField": "Some text",
+                        "UserField.Id": "ID001",
+                        "UserField.Name": "Name001",
+                        "CreatedBy": {"Name": "User001"},
+                        "Image": {"a": "b"},
+                    },
+                    {
+                        "TextField": "Some text",
+                        "UserField.Id": "ID001",
+                        "UserField.Name": "Name001",
+                        "CreatedBy": {"Name": "User001"},
+                        "Image": {"a": "b"},
+                    },
+                ],
+            ),
+        ],
+    )
+    def test_max_level_with_records_path(self, max_level, expected):
+        # GH23843: Enhanced JSON normalize
+        test_input = [
+            {
+                "CreatedBy": {"Name": "User001"},
+                "Lookup": [
+                    {
+                        "TextField": "Some text",
+                        "UserField": {"Id": "ID001", "Name": "Name001"},
+                    },
+                    {
+                        "TextField": "Some text",
+                        "UserField": {"Id": "ID001", "Name": "Name001"},
+                    },
+                ],
+                "Image": {"a": "b"},
+                "tags": [
+                    {"foo": "something", "bar": "else"},
+                    {"foo": "something2", "bar": "else2"},
+                ],
+            }
+        ]
+
+        result = json_normalize(
+            test_input,
+            record_path=["Lookup"],
+            meta=[["CreatedBy"], ["Image"]],
+            max_level=max_level,
+        )
+        expected_df = DataFrame(data=expected, columns=result.columns.values)
+        tm.assert_equal(expected_df, result)
+
+    def test_nested_flattening_consistent(self):
+        # see gh-21537
+        df1 = json_normalize([{"A": {"B": 1}}])
+        df2 = json_normalize({"dummy": [{"A": {"B": 1}}]}, "dummy")
+
+        # They should be the same.
+        tm.assert_frame_equal(df1, df2)
+
+    def test_nonetype_record_path(self, nulls_fixture):
+        # see gh-30148
+        # should not raise TypeError
+        result = json_normalize(
+            [
+                {"state": "Texas", "info": nulls_fixture},
+                {"state": "Florida", "info": [{"i": 2}]},
+            ],
+            record_path=["info"],
+        )
+        expected = DataFrame({"i": 2}, index=[0])
+        tm.assert_equal(result, expected)
+
+    @pytest.mark.parametrize("value", ["false", "true", "{}", "1", '"text"'])
+    def test_non_list_record_path_errors(self, value):
+        # see gh-30148, GH 26284
+        parsed_value = json.loads(value)
+        test_input = {"state": "Texas", "info": parsed_value}
+        test_path = "info"
+        msg = (
+            f"{test_input} has non list value {parsed_value} for path {test_path}. "
+            "Must be list or null."
+        )
+        with pytest.raises(TypeError, match=msg):
+            json_normalize([test_input], record_path=[test_path])
+
+    def test_meta_non_iterable(self):
+        # GH 31507
+        data = """[{"id": 99, "data": [{"one": 1, "two": 2}]}]"""
+
+        result = json_normalize(json.loads(data), record_path=["data"], meta=["id"])
+        expected = DataFrame(
+            {"one": [1], "two": [2], "id": np.array([99], dtype=object)}
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_generator(self, state_data):
+        # GH35923 Fix pd.json_normalize to not skip the first element of a
+        # generator input
+        def generator_data():
+            yield from state_data[0]["counties"]
+
+        result = json_normalize(generator_data())
+        expected = DataFrame(state_data[0]["counties"])
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_top_column_with_leading_underscore(self):
+        # 49861
+        data = {"_id": {"a1": 10, "l2": {"l3": 0}}, "gg": 4}
+        result = json_normalize(data, sep="_")
+        expected = DataFrame([[4, 10, 0]], columns=["gg", "_id_a1", "_id_l2_l3"])
+
+        tm.assert_frame_equal(result, expected)
+
+
+class TestNestedToRecord:
+    def test_flat_stays_flat(self):
+        recs = [{"flat1": 1, "flat2": 2}, {"flat3": 3, "flat2": 4}]
+        result = nested_to_record(recs)
+        expected = recs
+        assert result == expected
+
+    def test_one_level_deep_flattens(self):
+        data = {"flat1": 1, "dict1": {"c": 1, "d": 2}}
+
+        result = nested_to_record(data)
+        expected = {"dict1.c": 1, "dict1.d": 2, "flat1": 1}
+
+        assert result == expected
+
+    def test_nested_flattens(self):
+        data = {
+            "flat1": 1,
+            "dict1": {"c": 1, "d": 2},
+            "nested": {"e": {"c": 1, "d": 2}, "d": 2},
+        }
+
+        result = nested_to_record(data)
+        expected = {
+            "dict1.c": 1,
+            "dict1.d": 2,
+            "flat1": 1,
+            "nested.d": 2,
+            "nested.e.c": 1,
+            "nested.e.d": 2,
+        }
+
+        assert result == expected
+
+    def test_json_normalize_errors(self, missing_metadata):
+        # GH14583:
+        # If meta keys are not always present a new option to set
+        # errors='ignore' has been implemented
+
+        msg = (
+            "Key 'name' not found. To replace missing values of "
+            "'name' with np.nan, pass in errors='ignore'"
+        )
+        with pytest.raises(KeyError, match=msg):
+            json_normalize(
+                data=missing_metadata,
+                record_path="addresses",
+                meta="name",
+                errors="raise",
+            )
+
+    def test_missing_meta(self, missing_metadata):
+        # GH25468
+        # If metadata is nullable with errors set to ignore, the null values
+        # should be numpy.nan values
+        result = json_normalize(
+            data=missing_metadata, record_path="addresses", meta="name", errors="ignore"
+        )
+        ex_data = [
+            [9562, "Morris St.", "Massillon", "OH", 44646, "Alice"],
+            [8449, "Spring St.", "Elizabethton", "TN", 37643, np.nan],
+        ]
+        columns = ["number", "street", "city", "state", "zip", "name"]
+        expected = DataFrame(ex_data, columns=columns)
+        tm.assert_frame_equal(result, expected)
+
+    def test_missing_nested_meta(self):
+        # GH44312
+        # If errors="ignore" and nested metadata is null, we should return nan
+        data = {"meta": "foo", "nested_meta": None, "value": [{"rec": 1}, {"rec": 2}]}
+        result = json_normalize(
+            data,
+            record_path="value",
+            meta=["meta", ["nested_meta", "leaf"]],
+            errors="ignore",
+        )
+        ex_data = [[1, "foo", np.nan], [2, "foo", np.nan]]
+        columns = ["rec", "meta", "nested_meta.leaf"]
+        expected = DataFrame(ex_data, columns=columns).astype(
+            {"nested_meta.leaf": object}
+        )
+        tm.assert_frame_equal(result, expected)
+
+        # If errors="raise" and nested metadata is null, we should raise with the
+        # key of the first missing level
+        with pytest.raises(KeyError, match="'leaf' not found"):
+            json_normalize(
+                data,
+                record_path="value",
+                meta=["meta", ["nested_meta", "leaf"]],
+                errors="raise",
+            )
+
+    def test_missing_meta_multilevel_record_path_errors_raise(self, missing_metadata):
+        # GH41876
+        # Ensure errors='raise' works as intended even when a record_path of length
+        # greater than one is passed in
+        msg = (
+            "Key 'name' not found. To replace missing values of "
+            "'name' with np.nan, pass in errors='ignore'"
+        )
+        with pytest.raises(KeyError, match=msg):
+            json_normalize(
+                data=missing_metadata,
+                record_path=["previous_residences", "cities"],
+                meta="name",
+                errors="raise",
+            )
+
+    def test_missing_meta_multilevel_record_path_errors_ignore(self, missing_metadata):
+        # GH41876
+        # Ensure errors='ignore' works as intended even when a record_path of length
+        # greater than one is passed in
+        result = json_normalize(
+            data=missing_metadata,
+            record_path=["previous_residences", "cities"],
+            meta="name",
+            errors="ignore",
+        )
+        ex_data = [
+            ["Foo York City", "Alice"],
+            ["Barmingham", np.nan],
+        ]
+        columns = ["city_name", "name"]
+        expected = DataFrame(ex_data, columns=columns)
+        tm.assert_frame_equal(result, expected)
+
+    def test_donot_drop_nonevalues(self):
+        # GH21356
+        data = [
+            {"info": None, "author_name": {"first": "Smith", "last_name": "Appleseed"}},
+            {
+                "info": {"created_at": "11/08/1993", "last_updated": "26/05/2012"},
+                "author_name": {"first": "Jane", "last_name": "Doe"},
+            },
+        ]
+        result = nested_to_record(data)
+        expected = [
+            {
+                "info": None,
+                "author_name.first": "Smith",
+                "author_name.last_name": "Appleseed",
+            },
+            {
+                "author_name.first": "Jane",
+                "author_name.last_name": "Doe",
+                "info.created_at": "11/08/1993",
+                "info.last_updated": "26/05/2012",
+            },
+        ]
+
+        assert result == expected
+
+    def test_nonetype_top_level_bottom_level(self):
+        # GH21158: If inner level json has a key with a null value
+        # make sure it does not do a new_d.pop twice and except
+        data = {
+            "id": None,
+            "location": {
+                "country": {
+                    "state": {
+                        "id": None,
+                        "town.info": {
+                            "id": None,
+                            "region": None,
+                            "x": 49.151580810546875,
+                            "y": -33.148521423339844,
+                            "z": 27.572303771972656,
+                        },
+                    }
+                }
+            },
+        }
+        result = nested_to_record(data)
+        expected = {
+            "id": None,
+            "location.country.state.id": None,
+            "location.country.state.town.info.id": None,
+            "location.country.state.town.info.region": None,
+            "location.country.state.town.info.x": 49.151580810546875,
+            "location.country.state.town.info.y": -33.148521423339844,
+            "location.country.state.town.info.z": 27.572303771972656,
+        }
+        assert result == expected
+
+    def test_nonetype_multiple_levels(self):
+        # GH21158: If inner level json has a key with a null value
+        # make sure it does not do a new_d.pop twice and except
+        data = {
+            "id": None,
+            "location": {
+                "id": None,
+                "country": {
+                    "id": None,
+                    "state": {
+                        "id": None,
+                        "town.info": {
+                            "region": None,
+                            "x": 49.151580810546875,
+                            "y": -33.148521423339844,
+                            "z": 27.572303771972656,
+                        },
+                    },
+                },
+            },
+        }
+        result = nested_to_record(data)
+        expected = {
+            "id": None,
+            "location.id": None,
+            "location.country.id": None,
+            "location.country.state.id": None,
+            "location.country.state.town.info.region": None,
+            "location.country.state.town.info.x": 49.151580810546875,
+            "location.country.state.town.info.y": -33.148521423339844,
+            "location.country.state.town.info.z": 27.572303771972656,
+        }
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "max_level, expected",
+        [
+            (
+                None,
+                [
+                    {
+                        "CreatedBy.Name": "User001",
+                        "Lookup.TextField": "Some text",
+                        "Lookup.UserField.Id": "ID001",
+                        "Lookup.UserField.Name": "Name001",
+                        "Image.a": "b",
+                    }
+                ],
+            ),
+            (
+                0,
+                [
+                    {
+                        "CreatedBy": {"Name": "User001"},
+                        "Lookup": {
+                            "TextField": "Some text",
+                            "UserField": {"Id": "ID001", "Name": "Name001"},
+                        },
+                        "Image": {"a": "b"},
+                    }
+                ],
+            ),
+            (
+                1,
+                [
+                    {
+                        "CreatedBy.Name": "User001",
+                        "Lookup.TextField": "Some text",
+                        "Lookup.UserField": {"Id": "ID001", "Name": "Name001"},
+                        "Image.a": "b",
+                    }
+                ],
+            ),
+        ],
+    )
+    def test_with_max_level(self, max_level, expected, max_level_test_input_data):
+        # GH23843: Enhanced JSON normalize
+        output = nested_to_record(max_level_test_input_data, max_level=max_level)
+        assert output == expected
+
+    def test_with_large_max_level(self):
+        # GH23843: Enhanced JSON normalize
+        max_level = 100
+        input_data = [
+            {
+                "CreatedBy": {
+                    "user": {
+                        "name": {"firstname": "Leo", "LastName": "Thomson"},
+                        "family_tree": {
+                            "father": {
+                                "name": "Father001",
+                                "father": {
+                                    "Name": "Father002",
+                                    "father": {
+                                        "name": "Father003",
+                                        "father": {"Name": "Father004"},
+                                    },
+                                },
+                            }
+                        },
+                    }
+                }
+            }
+        ]
+        expected = [
+            {
+                "CreatedBy.user.name.firstname": "Leo",
+                "CreatedBy.user.name.LastName": "Thomson",
+                "CreatedBy.user.family_tree.father.name": "Father001",
+                "CreatedBy.user.family_tree.father.father.Name": "Father002",
+                "CreatedBy.user.family_tree.father.father.father.name": "Father003",
+                "CreatedBy.user.family_tree.father.father.father.father.Name": "Father004",  # noqa: E501
+            }
+        ]
+        output = nested_to_record(input_data, max_level=max_level)
+        assert output == expected
+
+    def test_series_non_zero_index(self):
+        # GH 19020
+        data = {
+            0: {"id": 1, "name": "Foo", "elements": {"a": 1}},
+            1: {"id": 2, "name": "Bar", "elements": {"b": 2}},
+            2: {"id": 3, "name": "Baz", "elements": {"c": 3}},
+        }
+        s = Series(data)
+        s.index = [1, 2, 3]
+        result = json_normalize(s)
+        expected = DataFrame(
+            {
+                "id": [1, 2, 3],
+                "name": ["Foo", "Bar", "Baz"],
+                "elements.a": [1.0, np.nan, np.nan],
+                "elements.b": [np.nan, 2.0, np.nan],
+                "elements.c": [np.nan, np.nan, 3.0],
+            }
+        )
+        tm.assert_frame_equal(result, expected)

llmeval-env/lib/python3.10/site-packages/pandas/tests/io/json/test_pandas.py

@@ -0,0 +1,2202 @@
+import datetime
+from datetime import timedelta
+from decimal import Decimal
+from io import (
+    BytesIO,
+    StringIO,
+)
+import json
+import os
+import sys
+import time
+
+import numpy as np
+import pytest
+
+from pandas._config import using_pyarrow_string_dtype
+
+from pandas.compat import IS64
+import pandas.util._test_decorators as td
+
+import pandas as pd
+from pandas import (
+    NA,
+    DataFrame,
+    DatetimeIndex,
+    Index,
+    RangeIndex,
+    Series,
+    Timestamp,
+    date_range,
+    read_json,
+)
+import pandas._testing as tm
+from pandas.core.arrays import (
+    ArrowStringArray,
+    StringArray,
+)
+from pandas.core.arrays.string_arrow import ArrowStringArrayNumpySemantics
+
+from pandas.io.json import ujson_dumps
+
+
+def test_literal_json_deprecation():
+    # PR 53409
+    expected = DataFrame([[1, 2], [1, 2]], columns=["a", "b"])
+
+    jsonl = """{"a": 1, "b": 2}
+        {"a": 3, "b": 4}
+        {"a": 5, "b": 6}
+        {"a": 7, "b": 8}"""
+
+    msg = (
+        "Passing literal json to 'read_json' is deprecated and "
+        "will be removed in a future version. To read from a "
+        "literal string, wrap it in a 'StringIO' object."
+    )
+
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        try:
+            read_json(jsonl, lines=False)
+        except ValueError:
+            pass
+
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        read_json(expected.to_json(), lines=False)
+
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = read_json('{"a": 1, "b": 2}\n{"b":2, "a" :1}\n', lines=True)
+        tm.assert_frame_equal(result, expected)
+
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        try:
+            result = read_json(
+                '{"a\\\\":"foo\\\\","b":"bar"}\n{"a\\\\":"foo\\"","b":"bar"}\n',
+                lines=False,
+            )
+        except ValueError:
+            pass
+
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        try:
+            result = read_json('{"a": 1, "b": 2}\n{"b":2, "a" :1}\n', lines=False)
+        except ValueError:
+            pass
+        tm.assert_frame_equal(result, expected)
+
+
+def assert_json_roundtrip_equal(result, expected, orient):
+    if orient in ("records", "values"):
+        expected = expected.reset_index(drop=True)
+    if orient == "values":
+        expected.columns = range(len(expected.columns))
+    tm.assert_frame_equal(result, expected)
+
+
+class TestPandasContainer:
+    @pytest.fixture
+    def categorical_frame(self):
+        data = {
+            c: np.random.default_rng(i).standard_normal(30)
+            for i, c in enumerate(list("ABCD"))
+        }
+        cat = ["bah"] * 5 + ["bar"] * 5 + ["baz"] * 5 + ["foo"] * 15
+        data["E"] = list(reversed(cat))
+        data["sort"] = np.arange(30, dtype="int64")
+        return DataFrame(data, index=pd.CategoricalIndex(cat, name="E"))
+
+    @pytest.fixture
+    def datetime_series(self):
+        # Same as usual datetime_series, but with index freq set to None,
+        #  since that doesn't round-trip, see GH#33711
+        ser = Series(
+            1.1 * np.arange(10, dtype=np.float64),
+            index=date_range("2020-01-01", periods=10),
+            name="ts",
+        )
+        ser.index = ser.index._with_freq(None)
+        return ser
+
+    @pytest.fixture
+    def datetime_frame(self):
+        # Same as usual datetime_frame, but with index freq set to None,
+        #  since that doesn't round-trip, see GH#33711
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((30, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=date_range("2000-01-01", periods=30, freq="B"),
+        )
+        df.index = df.index._with_freq(None)
+        return df
+
+    def test_frame_double_encoded_labels(self, orient):
+        df = DataFrame(
+            [["a", "b"], ["c", "d"]],
+            index=['index " 1', "index / 2"],
+            columns=["a \\ b", "y / z"],
+        )
+
+        data = StringIO(df.to_json(orient=orient))
+        result = read_json(data, orient=orient)
+        expected = df.copy()
+        assert_json_roundtrip_equal(result, expected, orient)
+
+    @pytest.mark.parametrize("orient", ["split", "records", "values"])
+    def test_frame_non_unique_index(self, orient):
+        df = DataFrame([["a", "b"], ["c", "d"]], index=[1, 1], columns=["x", "y"])
+        data = StringIO(df.to_json(orient=orient))
+        result = read_json(data, orient=orient)
+        expected = df.copy()
+
+        assert_json_roundtrip_equal(result, expected, orient)
+
+    @pytest.mark.parametrize("orient", ["index", "columns"])
+    def test_frame_non_unique_index_raises(self, orient):
+        df = DataFrame([["a", "b"], ["c", "d"]], index=[1, 1], columns=["x", "y"])
+        msg = f"DataFrame index must be unique for orient='{orient}'"
+        with pytest.raises(ValueError, match=msg):
+            df.to_json(orient=orient)
+
+    @pytest.mark.parametrize("orient", ["split", "values"])
+    @pytest.mark.parametrize(
+        "data",
+        [
+            [["a", "b"], ["c", "d"]],
+            [[1.5, 2.5], [3.5, 4.5]],
+            [[1, 2.5], [3, 4.5]],
+            [[Timestamp("20130101"), 3.5], [Timestamp("20130102"), 4.5]],
+        ],
+    )
+    def test_frame_non_unique_columns(self, orient, data):
+        df = DataFrame(data, index=[1, 2], columns=["x", "x"])
+
+        result = read_json(
+            StringIO(df.to_json(orient=orient)), orient=orient, convert_dates=["x"]
+        )
+        if orient == "values":
+            expected = DataFrame(data)
+            if expected.iloc[:, 0].dtype == "datetime64[ns]":
+                # orient == "values" by default will write Timestamp objects out
+                # in milliseconds; these are internally stored in nanosecond,
+                # so divide to get where we need
+                # TODO: a to_epoch method would also solve; see GH 14772
+                expected.isetitem(0, expected.iloc[:, 0].astype(np.int64) // 1000000)
+        elif orient == "split":
+            expected = df
+            expected.columns = ["x", "x.1"]
+
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("orient", ["index", "columns", "records"])
+    def test_frame_non_unique_columns_raises(self, orient):
+        df = DataFrame([["a", "b"], ["c", "d"]], index=[1, 2], columns=["x", "x"])
+
+        msg = f"DataFrame columns must be unique for orient='{orient}'"
+        with pytest.raises(ValueError, match=msg):
+            df.to_json(orient=orient)
+
+    def test_frame_default_orient(self, float_frame):
+        assert float_frame.to_json() == float_frame.to_json(orient="columns")
+
+    @pytest.mark.parametrize("dtype", [False, float])
+    @pytest.mark.parametrize("convert_axes", [True, False])
+    def test_roundtrip_simple(self, orient, convert_axes, dtype, float_frame):
+        data = StringIO(float_frame.to_json(orient=orient))
+        result = read_json(data, orient=orient, convert_axes=convert_axes, dtype=dtype)
+
+        expected = float_frame
+
+        assert_json_roundtrip_equal(result, expected, orient)
+
+    @pytest.mark.parametrize("dtype", [False, np.int64])
+    @pytest.mark.parametrize("convert_axes", [True, False])
+    def test_roundtrip_intframe(self, orient, convert_axes, dtype, int_frame):
+        data = StringIO(int_frame.to_json(orient=orient))
+        result = read_json(data, orient=orient, convert_axes=convert_axes, dtype=dtype)
+        expected = int_frame
+        assert_json_roundtrip_equal(result, expected, orient)
+
+    @pytest.mark.parametrize("dtype", [None, np.float64, int, "U3"])
+    @pytest.mark.parametrize("convert_axes", [True, False])
+    def test_roundtrip_str_axes(self, orient, convert_axes, dtype):
+        df = DataFrame(
+            np.zeros((200, 4)),
+            columns=[str(i) for i in range(4)],
+            index=[str(i) for i in range(200)],
+            dtype=dtype,
+        )
+
+        data = StringIO(df.to_json(orient=orient))
+        result = read_json(data, orient=orient, convert_axes=convert_axes, dtype=dtype)
+
+        expected = df.copy()
+        if not dtype:
+            expected = expected.astype(np.int64)
+
+        # index columns, and records orients cannot fully preserve the string
+        # dtype for axes as the index and column labels are used as keys in
+        # JSON objects. JSON keys are by definition strings, so there's no way
+        # to disambiguate whether those keys actually were strings or numeric
+        # beforehand and numeric wins out.
+        if convert_axes and (orient in ("index", "columns")):
+            expected.columns = expected.columns.astype(np.int64)
+            expected.index = expected.index.astype(np.int64)
+        elif orient == "records" and convert_axes:
+            expected.columns = expected.columns.astype(np.int64)
+        elif convert_axes and orient == "split":
+            expected.columns = expected.columns.astype(np.int64)
+
+        assert_json_roundtrip_equal(result, expected, orient)
+
+    @pytest.mark.parametrize("convert_axes", [True, False])
+    def test_roundtrip_categorical(
+        self, request, orient, categorical_frame, convert_axes, using_infer_string
+    ):
+        # TODO: create a better frame to test with and improve coverage
+        if orient in ("index", "columns"):
+            request.applymarker(
+                pytest.mark.xfail(
+                    reason=f"Can't have duplicate index values for orient '{orient}')"
+                )
+            )
+
+        data = StringIO(categorical_frame.to_json(orient=orient))
+        result = read_json(data, orient=orient, convert_axes=convert_axes)
+
+        expected = categorical_frame.copy()
+        expected.index = expected.index.astype(
+            str if not using_infer_string else "string[pyarrow_numpy]"
+        )  # Categorical not preserved
+        expected.index.name = None  # index names aren't preserved in JSON
+        assert_json_roundtrip_equal(result, expected, orient)
+
+    @pytest.mark.parametrize("convert_axes", [True, False])
+    def test_roundtrip_empty(self, orient, convert_axes):
+        empty_frame = DataFrame()
+        data = StringIO(empty_frame.to_json(orient=orient))
+        result = read_json(data, orient=orient, convert_axes=convert_axes)
+        if orient == "split":
+            idx = Index([], dtype=(float if convert_axes else object))
+            expected = DataFrame(index=idx, columns=idx)
+        elif orient in ["index", "columns"]:
+            expected = DataFrame()
+        else:
+            expected = empty_frame.copy()
+
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("convert_axes", [True, False])
+    def test_roundtrip_timestamp(self, orient, convert_axes, datetime_frame):
+        # TODO: improve coverage with date_format parameter
+        data = StringIO(datetime_frame.to_json(orient=orient))
+        result = read_json(data, orient=orient, convert_axes=convert_axes)
+        expected = datetime_frame.copy()
+
+        if not convert_axes:  # one off for ts handling
+            # DTI gets converted to epoch values
+            idx = expected.index.view(np.int64) // 1000000
+            if orient != "split":  # TODO: handle consistently across orients
+                idx = idx.astype(str)
+
+            expected.index = idx
+
+        assert_json_roundtrip_equal(result, expected, orient)
+
+    @pytest.mark.parametrize("convert_axes", [True, False])
+    def test_roundtrip_mixed(self, orient, convert_axes):
+        index = Index(["a", "b", "c", "d", "e"])
+        values = {
+            "A": [0.0, 1.0, 2.0, 3.0, 4.0],
+            "B": [0.0, 1.0, 0.0, 1.0, 0.0],
+            "C": ["foo1", "foo2", "foo3", "foo4", "foo5"],
+            "D": [True, False, True, False, True],
+        }
+
+        df = DataFrame(data=values, index=index)
+
+        data = StringIO(df.to_json(orient=orient))
+        result = read_json(data, orient=orient, convert_axes=convert_axes)
+
+        expected = df.copy()
+        expected = expected.assign(**expected.select_dtypes("number").astype(np.int64))
+
+        assert_json_roundtrip_equal(result, expected, orient)
+
+    @pytest.mark.xfail(
+        reason="#50456 Column multiindex is stored and loaded differently",
+        raises=AssertionError,
+    )
+    @pytest.mark.parametrize(
+        "columns",
+        [
+            [["2022", "2022"], ["JAN", "FEB"]],
+            [["2022", "2023"], ["JAN", "JAN"]],
+            [["2022", "2022"], ["JAN", "JAN"]],
+        ],
+    )
+    def test_roundtrip_multiindex(self, columns):
+        df = DataFrame(
+            [[1, 2], [3, 4]],
+            columns=pd.MultiIndex.from_arrays(columns),
+        )
+        data = StringIO(df.to_json(orient="split"))
+        result = read_json(data, orient="split")
+        tm.assert_frame_equal(result, df)
+
+    @pytest.mark.parametrize(
+        "data,msg,orient",
+        [
+            ('{"key":b:a:d}', "Expected object or value", "columns"),
+            # too few indices
+            (
+                '{"columns":["A","B"],'
+                '"index":["2","3"],'
+                '"data":[[1.0,"1"],[2.0,"2"],[null,"3"]]}',
+                "|".join(
+                    [
+                        r"Length of values \(3\) does not match length of index \(2\)",
+                    ]
+                ),
+                "split",
+            ),
+            # too many columns
+            (
+                '{"columns":["A","B","C"],'
+                '"index":["1","2","3"],'
+                '"data":[[1.0,"1"],[2.0,"2"],[null,"3"]]}',
+                "3 columns passed, passed data had 2 columns",
+                "split",
+            ),
+            # bad key
+            (
+                '{"badkey":["A","B"],'
+                '"index":["2","3"],'
+                '"data":[[1.0,"1"],[2.0,"2"],[null,"3"]]}',
+                r"unexpected key\(s\): badkey",
+                "split",
+            ),
+        ],
+    )
+    def test_frame_from_json_bad_data_raises(self, data, msg, orient):
+        with pytest.raises(ValueError, match=msg):
+            read_json(StringIO(data), orient=orient)
+
+    @pytest.mark.parametrize("dtype", [True, False])
+    @pytest.mark.parametrize("convert_axes", [True, False])
+    def test_frame_from_json_missing_data(self, orient, convert_axes, dtype):
+        num_df = DataFrame([[1, 2], [4, 5, 6]])
+
+        result = read_json(
+            StringIO(num_df.to_json(orient=orient)),
+            orient=orient,
+            convert_axes=convert_axes,
+            dtype=dtype,
+        )
+        assert np.isnan(result.iloc[0, 2])
+
+        obj_df = DataFrame([["1", "2"], ["4", "5", "6"]])
+        result = read_json(
+            StringIO(obj_df.to_json(orient=orient)),
+            orient=orient,
+            convert_axes=convert_axes,
+            dtype=dtype,
+        )
+        assert np.isnan(result.iloc[0, 2])
+
+    @pytest.mark.parametrize("dtype", [True, False])
+    def test_frame_read_json_dtype_missing_value(self, dtype):
+        # GH28501 Parse missing values using read_json with dtype=False
+        # to NaN instead of None
+        result = read_json(StringIO("[null]"), dtype=dtype)
+        expected = DataFrame([np.nan])
+
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("inf", [np.inf, -np.inf])
+    @pytest.mark.parametrize("dtype", [True, False])
+    def test_frame_infinity(self, inf, dtype):
+        # infinities get mapped to nulls which get mapped to NaNs during
+        # deserialisation
+        df = DataFrame([[1, 2], [4, 5, 6]])
+        df.loc[0, 2] = inf
+
+        data = StringIO(df.to_json())
+        result = read_json(data, dtype=dtype)
+        assert np.isnan(result.iloc[0, 2])
+
+    @pytest.mark.skipif(not IS64, reason="not compliant on 32-bit, xref #15865")
+    @pytest.mark.parametrize(
+        "value,precision,expected_val",
+        [
+            (0.95, 1, 1.0),
+            (1.95, 1, 2.0),
+            (-1.95, 1, -2.0),
+            (0.995, 2, 1.0),
+            (0.9995, 3, 1.0),
+            (0.99999999999999944, 15, 1.0),
+        ],
+    )
+    def test_frame_to_json_float_precision(self, value, precision, expected_val):
+        df = DataFrame([{"a_float": value}])
+        encoded = df.to_json(double_precision=precision)
+        assert encoded == f'{{"a_float":{{"0":{expected_val}}}}}'
+
+    def test_frame_to_json_except(self):
+        df = DataFrame([1, 2, 3])
+        msg = "Invalid value 'garbage' for option 'orient'"
+        with pytest.raises(ValueError, match=msg):
+            df.to_json(orient="garbage")
+
+    def test_frame_empty(self):
+        df = DataFrame(columns=["jim", "joe"])
+        assert not df._is_mixed_type
+
+        data = StringIO(df.to_json())
+        result = read_json(data, dtype=dict(df.dtypes))
+        tm.assert_frame_equal(result, df, check_index_type=False)
+
+    def test_frame_empty_to_json(self):
+        # GH 7445
+        df = DataFrame({"test": []}, index=[])
+        result = df.to_json(orient="columns")
+        expected = '{"test":{}}'
+        assert result == expected
+
+    def test_frame_empty_mixedtype(self):
+        # mixed type
+        df = DataFrame(columns=["jim", "joe"])
+        df["joe"] = df["joe"].astype("i8")
+        assert df._is_mixed_type
+        data = df.to_json()
+        tm.assert_frame_equal(
+            read_json(StringIO(data), dtype=dict(df.dtypes)),
+            df,
+            check_index_type=False,
+        )
+
+    def test_frame_mixedtype_orient(self):  # GH10289
+        vals = [
+            [10, 1, "foo", 0.1, 0.01],
+            [20, 2, "bar", 0.2, 0.02],
+            [30, 3, "baz", 0.3, 0.03],
+            [40, 4, "qux", 0.4, 0.04],
+        ]
+
+        df = DataFrame(
+            vals, index=list("abcd"), columns=["1st", "2nd", "3rd", "4th", "5th"]
+        )
+
+        assert df._is_mixed_type
+        right = df.copy()
+
+        for orient in ["split", "index", "columns"]:
+            inp = StringIO(df.to_json(orient=orient))
+            left = read_json(inp, orient=orient, convert_axes=False)
+            tm.assert_frame_equal(left, right)
+
+        right.index = RangeIndex(len(df))
+        inp = StringIO(df.to_json(orient="records"))
+        left = read_json(inp, orient="records", convert_axes=False)
+        tm.assert_frame_equal(left, right)
+
+        right.columns = RangeIndex(df.shape[1])
+        inp = StringIO(df.to_json(orient="values"))
+        left = read_json(inp, orient="values", convert_axes=False)
+        tm.assert_frame_equal(left, right)
+
+    def test_v12_compat(self, datapath):
+        dti = date_range("2000-01-03", "2000-01-07")
+        # freq doesn't roundtrip
+        dti = DatetimeIndex(np.asarray(dti), freq=None)
+        df = DataFrame(
+            [
+                [1.56808523, 0.65727391, 1.81021139, -0.17251653],
+                [-0.2550111, -0.08072427, -0.03202878, -0.17581665],
+                [1.51493992, 0.11805825, 1.629455, -1.31506612],
+                [-0.02765498, 0.44679743, 0.33192641, -0.27885413],
+                [0.05951614, -2.69652057, 1.28163262, 0.34703478],
+            ],
+            columns=["A", "B", "C", "D"],
+            index=dti,
+        )
+        df["date"] = Timestamp("19920106 18:21:32.12").as_unit("ns")
+        df.iloc[3, df.columns.get_loc("date")] = Timestamp("20130101")
+        df["modified"] = df["date"]
+        df.iloc[1, df.columns.get_loc("modified")] = pd.NaT
+
+        dirpath = datapath("io", "json", "data")
+        v12_json = os.path.join(dirpath, "tsframe_v012.json")
+        df_unser = read_json(v12_json)
+        tm.assert_frame_equal(df, df_unser)
+
+        df_iso = df.drop(["modified"], axis=1)
+        v12_iso_json = os.path.join(dirpath, "tsframe_iso_v012.json")
+        df_unser_iso = read_json(v12_iso_json)
+        tm.assert_frame_equal(df_iso, df_unser_iso, check_column_type=False)
+
+    def test_blocks_compat_GH9037(self, using_infer_string):
+        index = date_range("20000101", periods=10, freq="h")
+        # freq doesn't round-trip
+        index = DatetimeIndex(list(index), freq=None)
+
+        df_mixed = DataFrame(
+            {
+                "float_1": [
+                    -0.92077639,
+                    0.77434435,
+                    1.25234727,
+                    0.61485564,
+                    -0.60316077,
+                    0.24653374,
+                    0.28668979,
+                    -2.51969012,
+                    0.95748401,
+                    -1.02970536,
+                ],
+                "int_1": [
+                    19680418,
+                    75337055,
+                    99973684,
+                    65103179,
+                    79373900,
+                    40314334,
+                    21290235,
+                    4991321,
+                    41903419,
+                    16008365,
+                ],
+                "str_1": [
+                    "78c608f1",
+                    "64a99743",
+                    "13d2ff52",
+                    "ca7f4af2",
+                    "97236474",
+                    "bde7e214",
+                    "1a6bde47",
+                    "b1190be5",
+                    "7a669144",
+                    "8d64d068",
+                ],
+                "float_2": [
+                    -0.0428278,
+                    -1.80872357,
+                    3.36042349,
+                    -0.7573685,
+                    -0.48217572,
+                    0.86229683,
+                    1.08935819,
+                    0.93898739,
+                    -0.03030452,
+                    1.43366348,
+                ],
+                "str_2": [
+                    "14f04af9",
+                    "d085da90",
+                    "4bcfac83",
+                    "81504caf",
+                    "2ffef4a9",
+                    "08e2f5c4",
+                    "07e1af03",
+                    "addbd4a7",
+                    "1f6a09ba",
+                    "4bfc4d87",
+                ],
+                "int_2": [
+                    86967717,
+                    98098830,
+                    51927505,
+                    20372254,
+                    12601730,
+                    20884027,
+                    34193846,
+                    10561746,
+                    24867120,
+                    76131025,
+                ],
+            },
+            index=index,
+        )
+
+        # JSON deserialisation always creates unicode strings
+        df_mixed.columns = df_mixed.columns.astype(
+            np.str_ if not using_infer_string else "string[pyarrow_numpy]"
+        )
+        data = StringIO(df_mixed.to_json(orient="split"))
+        df_roundtrip = read_json(data, orient="split")
+        tm.assert_frame_equal(
+            df_mixed,
+            df_roundtrip,
+            check_index_type=True,
+            check_column_type=True,
+            by_blocks=True,
+            check_exact=True,
+        )
+
+    def test_frame_nonprintable_bytes(self):
+        # GH14256: failing column caused segfaults, if it is not the last one
+
+        class BinaryThing:
+            def __init__(self, hexed) -> None:
+                self.hexed = hexed
+                self.binary = bytes.fromhex(hexed)
+
+            def __str__(self) -> str:
+                return self.hexed
+
+        hexed = "574b4454ba8c5eb4f98a8f45"
+        binthing = BinaryThing(hexed)
+
+        # verify the proper conversion of printable content
+        df_printable = DataFrame({"A": [binthing.hexed]})
+        assert df_printable.to_json() == f'{{"A":{{"0":"{hexed}"}}}}'
+
+        # check if non-printable content throws appropriate Exception
+        df_nonprintable = DataFrame({"A": [binthing]})
+        msg = "Unsupported UTF-8 sequence length when encoding string"
+        with pytest.raises(OverflowError, match=msg):
+            df_nonprintable.to_json()
+
+        # the same with multiple columns threw segfaults
+        df_mixed = DataFrame({"A": [binthing], "B": [1]}, columns=["A", "B"])
+        with pytest.raises(OverflowError, match=msg):
+            df_mixed.to_json()
+
+        # default_handler should resolve exceptions for non-string types
+        result = df_nonprintable.to_json(default_handler=str)
+        expected = f'{{"A":{{"0":"{hexed}"}}}}'
+        assert result == expected
+        assert (
+            df_mixed.to_json(default_handler=str)
+            == f'{{"A":{{"0":"{hexed}"}},"B":{{"0":1}}}}'
+        )
+
+    def test_label_overflow(self):
+        # GH14256: buffer length not checked when writing label
+        result = DataFrame({"bar" * 100000: [1], "foo": [1337]}).to_json()
+        expected = f'{{"{"bar" * 100000}":{{"0":1}},"foo":{{"0":1337}}}}'
+        assert result == expected
+
+    def test_series_non_unique_index(self):
+        s = Series(["a", "b"], index=[1, 1])
+
+        msg = "Series index must be unique for orient='index'"
+        with pytest.raises(ValueError, match=msg):
+            s.to_json(orient="index")
+
+        tm.assert_series_equal(
+            s,
+            read_json(
+                StringIO(s.to_json(orient="split")), orient="split", typ="series"
+            ),
+        )
+        unserialized = read_json(
+            StringIO(s.to_json(orient="records")), orient="records", typ="series"
+        )
+        tm.assert_equal(s.values, unserialized.values)
+
+    def test_series_default_orient(self, string_series):
+        assert string_series.to_json() == string_series.to_json(orient="index")
+
+    def test_series_roundtrip_simple(self, orient, string_series, using_infer_string):
+        data = StringIO(string_series.to_json(orient=orient))
+        result = read_json(data, typ="series", orient=orient)
+
+        expected = string_series
+        if using_infer_string and orient in ("split", "index", "columns"):
+            # These schemas don't contain dtypes, so we infer string
+            expected.index = expected.index.astype("string[pyarrow_numpy]")
+        if orient in ("values", "records"):
+            expected = expected.reset_index(drop=True)
+        if orient != "split":
+            expected.name = None
+
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("dtype", [False, None])
+    def test_series_roundtrip_object(self, orient, dtype, object_series):
+        data = StringIO(object_series.to_json(orient=orient))
+        result = read_json(data, typ="series", orient=orient, dtype=dtype)
+
+        expected = object_series
+        if orient in ("values", "records"):
+            expected = expected.reset_index(drop=True)
+        if orient != "split":
+            expected.name = None
+
+        tm.assert_series_equal(result, expected)
+
+    def test_series_roundtrip_empty(self, orient):
+        empty_series = Series([], index=[], dtype=np.float64)
+        data = StringIO(empty_series.to_json(orient=orient))
+        result = read_json(data, typ="series", orient=orient)
+
+        expected = empty_series.reset_index(drop=True)
+        if orient in ("split"):
+            expected.index = expected.index.astype(np.float64)
+
+        tm.assert_series_equal(result, expected)
+
+    def test_series_roundtrip_timeseries(self, orient, datetime_series):
+        data = StringIO(datetime_series.to_json(orient=orient))
+        result = read_json(data, typ="series", orient=orient)
+
+        expected = datetime_series
+        if orient in ("values", "records"):
+            expected = expected.reset_index(drop=True)
+        if orient != "split":
+            expected.name = None
+
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("dtype", [np.float64, int])
+    def test_series_roundtrip_numeric(self, orient, dtype):
+        s = Series(range(6), index=["a", "b", "c", "d", "e", "f"])
+        data = StringIO(s.to_json(orient=orient))
+        result = read_json(data, typ="series", orient=orient)
+
+        expected = s.copy()
+        if orient in ("values", "records"):
+            expected = expected.reset_index(drop=True)
+
+        tm.assert_series_equal(result, expected)
+
+    def test_series_to_json_except(self):
+        s = Series([1, 2, 3])
+        msg = "Invalid value 'garbage' for option 'orient'"
+        with pytest.raises(ValueError, match=msg):
+            s.to_json(orient="garbage")
+
+    def test_series_from_json_precise_float(self):
+        s = Series([4.56, 4.56, 4.56])
+        result = read_json(StringIO(s.to_json()), typ="series", precise_float=True)
+        tm.assert_series_equal(result, s, check_index_type=False)
+
+    def test_series_with_dtype(self):
+        # GH 21986
+        s = Series([4.56, 4.56, 4.56])
+        result = read_json(StringIO(s.to_json()), typ="series", dtype=np.int64)
+        expected = Series([4] * 3)
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "dtype,expected",
+        [
+            (True, Series(["2000-01-01"], dtype="datetime64[ns]")),
+            (False, Series([946684800000])),
+        ],
+    )
+    def test_series_with_dtype_datetime(self, dtype, expected):
+        s = Series(["2000-01-01"], dtype="datetime64[ns]")
+        data = StringIO(s.to_json())
+        result = read_json(data, typ="series", dtype=dtype)
+        tm.assert_series_equal(result, expected)
+
+    def test_frame_from_json_precise_float(self):
+        df = DataFrame([[4.56, 4.56, 4.56], [4.56, 4.56, 4.56]])
+        result = read_json(StringIO(df.to_json()), precise_float=True)
+        tm.assert_frame_equal(result, df)
+
+    def test_typ(self):
+        s = Series(range(6), index=["a", "b", "c", "d", "e", "f"], dtype="int64")
+        result = read_json(StringIO(s.to_json()), typ=None)
+        tm.assert_series_equal(result, s)
+
+    def test_reconstruction_index(self):
+        df = DataFrame([[1, 2, 3], [4, 5, 6]])
+        result = read_json(StringIO(df.to_json()))
+        tm.assert_frame_equal(result, df)
+
+        df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]}, index=["A", "B", "C"])
+        result = read_json(StringIO(df.to_json()))
+        tm.assert_frame_equal(result, df)
+
+    def test_path(self, float_frame, int_frame, datetime_frame):
+        with tm.ensure_clean("test.json") as path:
+            for df in [float_frame, int_frame, datetime_frame]:
+                df.to_json(path)
+                read_json(path)
+
+    def test_axis_dates(self, datetime_series, datetime_frame):
+        # frame
+        json = StringIO(datetime_frame.to_json())
+        result = read_json(json)
+        tm.assert_frame_equal(result, datetime_frame)
+
+        # series
+        json = StringIO(datetime_series.to_json())
+        result = read_json(json, typ="series")
+        tm.assert_series_equal(result, datetime_series, check_names=False)
+        assert result.name is None
+
+    def test_convert_dates(self, datetime_series, datetime_frame):
+        # frame
+        df = datetime_frame
+        df["date"] = Timestamp("20130101").as_unit("ns")
+
+        json = StringIO(df.to_json())
+        result = read_json(json)
+        tm.assert_frame_equal(result, df)
+
+        df["foo"] = 1.0
+        json = StringIO(df.to_json(date_unit="ns"))
+
+        result = read_json(json, convert_dates=False)
+        expected = df.copy()
+        expected["date"] = expected["date"].values.view("i8")
+        expected["foo"] = expected["foo"].astype("int64")
+        tm.assert_frame_equal(result, expected)
+
+        # series
+        ts = Series(Timestamp("20130101").as_unit("ns"), index=datetime_series.index)
+        json = StringIO(ts.to_json())
+        result = read_json(json, typ="series")
+        tm.assert_series_equal(result, ts)
+
+    @pytest.mark.parametrize("date_format", ["epoch", "iso"])
+    @pytest.mark.parametrize("as_object", [True, False])
+    @pytest.mark.parametrize("date_typ", [datetime.date, datetime.datetime, Timestamp])
+    def test_date_index_and_values(self, date_format, as_object, date_typ):
+        data = [date_typ(year=2020, month=1, day=1), pd.NaT]
+        if as_object:
+            data.append("a")
+
+        ser = Series(data, index=data)
+        result = ser.to_json(date_format=date_format)
+
+        if date_format == "epoch":
+            expected = '{"1577836800000":1577836800000,"null":null}'
+        else:
+            expected = (
+                '{"2020-01-01T00:00:00.000":"2020-01-01T00:00:00.000","null":null}'
+            )
+
+        if as_object:
+            expected = expected.replace("}", ',"a":"a"}')
+
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "infer_word",
+        [
+            "trade_time",
+            "date",
+            "datetime",
+            "sold_at",
+            "modified",
+            "timestamp",
+            "timestamps",
+        ],
+    )
+    def test_convert_dates_infer(self, infer_word):
+        # GH10747
+
+        data = [{"id": 1, infer_word: 1036713600000}, {"id": 2}]
+        expected = DataFrame(
+            [[1, Timestamp("2002-11-08")], [2, pd.NaT]], columns=["id", infer_word]
+        )
+
+        result = read_json(StringIO(ujson_dumps(data)))[["id", infer_word]]
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "date,date_unit",
+        [
+            ("20130101 20:43:42.123", None),
+            ("20130101 20:43:42", "s"),
+            ("20130101 20:43:42.123", "ms"),
+            ("20130101 20:43:42.123456", "us"),
+            ("20130101 20:43:42.123456789", "ns"),
+        ],
+    )
+    def test_date_format_frame(self, date, date_unit, datetime_frame):
+        df = datetime_frame
+
+        df["date"] = Timestamp(date).as_unit("ns")
+        df.iloc[1, df.columns.get_loc("date")] = pd.NaT
+        df.iloc[5, df.columns.get_loc("date")] = pd.NaT
+        if date_unit:
+            json = df.to_json(date_format="iso", date_unit=date_unit)
+        else:
+            json = df.to_json(date_format="iso")
+
+        result = read_json(StringIO(json))
+        expected = df.copy()
+        tm.assert_frame_equal(result, expected)
+
+    def test_date_format_frame_raises(self, datetime_frame):
+        df = datetime_frame
+        msg = "Invalid value 'foo' for option 'date_unit'"
+        with pytest.raises(ValueError, match=msg):
+            df.to_json(date_format="iso", date_unit="foo")
+
+    @pytest.mark.parametrize(
+        "date,date_unit",
+        [
+            ("20130101 20:43:42.123", None),
+            ("20130101 20:43:42", "s"),
+            ("20130101 20:43:42.123", "ms"),
+            ("20130101 20:43:42.123456", "us"),
+            ("20130101 20:43:42.123456789", "ns"),
+        ],
+    )
+    def test_date_format_series(self, date, date_unit, datetime_series):
+        ts = Series(Timestamp(date).as_unit("ns"), index=datetime_series.index)
+        ts.iloc[1] = pd.NaT
+        ts.iloc[5] = pd.NaT
+        if date_unit:
+            json = ts.to_json(date_format="iso", date_unit=date_unit)
+        else:
+            json = ts.to_json(date_format="iso")
+
+        result = read_json(StringIO(json), typ="series")
+        expected = ts.copy()
+        tm.assert_series_equal(result, expected)
+
+    def test_date_format_series_raises(self, datetime_series):
+        ts = Series(Timestamp("20130101 20:43:42.123"), index=datetime_series.index)
+        msg = "Invalid value 'foo' for option 'date_unit'"
+        with pytest.raises(ValueError, match=msg):
+            ts.to_json(date_format="iso", date_unit="foo")
+
+    @pytest.mark.parametrize("unit", ["s", "ms", "us", "ns"])
+    def test_date_unit(self, unit, datetime_frame):
+        df = datetime_frame
+        df["date"] = Timestamp("20130101 20:43:42").as_unit("ns")
+        dl = df.columns.get_loc("date")
+        df.iloc[1, dl] = Timestamp("19710101 20:43:42")
+        df.iloc[2, dl] = Timestamp("21460101 20:43:42")
+        df.iloc[4, dl] = pd.NaT
+
+        json = df.to_json(date_format="epoch", date_unit=unit)
+
+        # force date unit
+        result = read_json(StringIO(json), date_unit=unit)
+        tm.assert_frame_equal(result, df)
+
+        # detect date unit
+        result = read_json(StringIO(json), date_unit=None)
+        tm.assert_frame_equal(result, df)
+
+    @pytest.mark.parametrize("unit", ["s", "ms", "us"])
+    def test_iso_non_nano_datetimes(self, unit):
+        # Test that numpy datetimes
+        # in an Index or a column with non-nano resolution can be serialized
+        # correctly
+        # GH53686
+        index = DatetimeIndex(
+            [np.datetime64("2023-01-01T11:22:33.123456", unit)],
+            dtype=f"datetime64[{unit}]",
+        )
+        df = DataFrame(
+            {
+                "date": Series(
+                    [np.datetime64("2022-01-01T11:22:33.123456", unit)],
+                    dtype=f"datetime64[{unit}]",
+                    index=index,
+                ),
+                "date_obj": Series(
+                    [np.datetime64("2023-01-01T11:22:33.123456", unit)],
+                    dtype=object,
+                    index=index,
+                ),
+            },
+        )
+
+        buf = StringIO()
+        df.to_json(buf, date_format="iso", date_unit=unit)
+        buf.seek(0)
+
+        # read_json always reads datetimes in nanosecond resolution
+        # TODO: check_dtype/check_index_type should be removable
+        # once read_json gets non-nano support
+        tm.assert_frame_equal(
+            read_json(buf, convert_dates=["date", "date_obj"]),
+            df,
+            check_index_type=False,
+            check_dtype=False,
+        )
+
+    def test_weird_nested_json(self):
+        # this used to core dump the parser
+        s = r"""{
+        "status": "success",
+        "data": {
+        "posts": [
+            {
+            "id": 1,
+            "title": "A blog post",
+            "body": "Some useful content"
+            },
+            {
+            "id": 2,
+            "title": "Another blog post",
+            "body": "More content"
+            }
+           ]
+          }
+        }"""
+        read_json(StringIO(s))
+
+    def test_doc_example(self):
+        dfj2 = DataFrame(
+            np.random.default_rng(2).standard_normal((5, 2)), columns=list("AB")
+        )
+        dfj2["date"] = Timestamp("20130101")
+        dfj2["ints"] = range(5)
+        dfj2["bools"] = True
+        dfj2.index = date_range("20130101", periods=5)
+
+        json = StringIO(dfj2.to_json())
+        result = read_json(json, dtype={"ints": np.int64, "bools": np.bool_})
+        tm.assert_frame_equal(result, result)
+
+    def test_round_trip_exception(self, datapath):
+        # GH 3867
+        path = datapath("io", "json", "data", "teams.csv")
+        df = pd.read_csv(path)
+        s = df.to_json()
+
+        result = read_json(StringIO(s))
+        res = result.reindex(index=df.index, columns=df.columns)
+        msg = "The 'downcast' keyword in fillna is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            res = res.fillna(np.nan, downcast=False)
+        tm.assert_frame_equal(res, df)
+
+    @pytest.mark.network
+    @pytest.mark.single_cpu
+    @pytest.mark.parametrize(
+        "field,dtype",
+        [
+            ["created_at", pd.DatetimeTZDtype(tz="UTC")],
+            ["closed_at", "datetime64[ns]"],
+            ["updated_at", pd.DatetimeTZDtype(tz="UTC")],
+        ],
+    )
+    def test_url(self, field, dtype, httpserver):
+        data = '{"created_at": ["2023-06-23T18:21:36Z"], "closed_at": ["2023-06-23T18:21:36"], "updated_at": ["2023-06-23T18:21:36Z"]}\n'  # noqa: E501
+        httpserver.serve_content(content=data)
+        result = read_json(httpserver.url, convert_dates=True)
+        assert result[field].dtype == dtype
+
+    def test_timedelta(self):
+        converter = lambda x: pd.to_timedelta(x, unit="ms")
+
+        ser = Series([timedelta(23), timedelta(seconds=5)])
+        assert ser.dtype == "timedelta64[ns]"
+
+        result = read_json(StringIO(ser.to_json()), typ="series").apply(converter)
+        tm.assert_series_equal(result, ser)
+
+        ser = Series([timedelta(23), timedelta(seconds=5)], index=Index([0, 1]))
+        assert ser.dtype == "timedelta64[ns]"
+        result = read_json(StringIO(ser.to_json()), typ="series").apply(converter)
+        tm.assert_series_equal(result, ser)
+
+        frame = DataFrame([timedelta(23), timedelta(seconds=5)])
+        assert frame[0].dtype == "timedelta64[ns]"
+        tm.assert_frame_equal(
+            frame, read_json(StringIO(frame.to_json())).apply(converter)
+        )
+
+    def test_timedelta2(self):
+        frame = DataFrame(
+            {
+                "a": [timedelta(days=23), timedelta(seconds=5)],
+                "b": [1, 2],
+                "c": date_range(start="20130101", periods=2),
+            }
+        )
+        data = StringIO(frame.to_json(date_unit="ns"))
+        result = read_json(data)
+        result["a"] = pd.to_timedelta(result.a, unit="ns")
+        result["c"] = pd.to_datetime(result.c)
+        tm.assert_frame_equal(frame, result)
+
+    def test_mixed_timedelta_datetime(self):
+        td = timedelta(23)
+        ts = Timestamp("20130101")
+        frame = DataFrame({"a": [td, ts]}, dtype=object)
+
+        expected = DataFrame(
+            {"a": [pd.Timedelta(td).as_unit("ns")._value, ts.as_unit("ns")._value]}
+        )
+        data = StringIO(frame.to_json(date_unit="ns"))
+        result = read_json(data, dtype={"a": "int64"})
+        tm.assert_frame_equal(result, expected, check_index_type=False)
+
+    @pytest.mark.parametrize("as_object", [True, False])
+    @pytest.mark.parametrize("date_format", ["iso", "epoch"])
+    @pytest.mark.parametrize("timedelta_typ", [pd.Timedelta, timedelta])
+    def test_timedelta_to_json(self, as_object, date_format, timedelta_typ):
+        # GH28156: to_json not correctly formatting Timedelta
+        data = [timedelta_typ(days=1), timedelta_typ(days=2), pd.NaT]
+        if as_object:
+            data.append("a")
+
+        ser = Series(data, index=data)
+        if date_format == "iso":
+            expected = (
+                '{"P1DT0H0M0S":"P1DT0H0M0S","P2DT0H0M0S":"P2DT0H0M0S","null":null}'
+            )
+        else:
+            expected = '{"86400000":86400000,"172800000":172800000,"null":null}'
+
+        if as_object:
+            expected = expected.replace("}", ',"a":"a"}')
+
+        result = ser.to_json(date_format=date_format)
+        assert result == expected
+
+    @pytest.mark.parametrize("as_object", [True, False])
+    @pytest.mark.parametrize("timedelta_typ", [pd.Timedelta, timedelta])
+    def test_timedelta_to_json_fractional_precision(self, as_object, timedelta_typ):
+        data = [timedelta_typ(milliseconds=42)]
+        ser = Series(data, index=data)
+        if as_object:
+            ser = ser.astype(object)
+
+        result = ser.to_json()
+        expected = '{"42":42}'
+        assert result == expected
+
+    def test_default_handler(self):
+        value = object()
+        frame = DataFrame({"a": [7, value]})
+        expected = DataFrame({"a": [7, str(value)]})
+        result = read_json(StringIO(frame.to_json(default_handler=str)))
+        tm.assert_frame_equal(expected, result, check_index_type=False)
+
+    def test_default_handler_indirect(self):
+        def default(obj):
+            if isinstance(obj, complex):
+                return [("mathjs", "Complex"), ("re", obj.real), ("im", obj.imag)]
+            return str(obj)
+
+        df_list = [
+            9,
+            DataFrame(
+                {"a": [1, "STR", complex(4, -5)], "b": [float("nan"), None, "N/A"]},
+                columns=["a", "b"],
+            ),
+        ]
+        expected = (
+            '[9,[[1,null],["STR",null],[[["mathjs","Complex"],'
+            '["re",4.0],["im",-5.0]],"N\\/A"]]]'
+        )
+        assert (
+            ujson_dumps(df_list, default_handler=default, orient="values") == expected
+        )
+
+    def test_default_handler_numpy_unsupported_dtype(self):
+        # GH12554 to_json raises 'Unhandled numpy dtype 15'
+        df = DataFrame(
+            {"a": [1, 2.3, complex(4, -5)], "b": [float("nan"), None, complex(1.2, 0)]},
+            columns=["a", "b"],
+        )
+        expected = (
+            '[["(1+0j)","(nan+0j)"],'
+            '["(2.3+0j)","(nan+0j)"],'
+            '["(4-5j)","(1.2+0j)"]]'
+        )
+        assert df.to_json(default_handler=str, orient="values") == expected
+
+    def test_default_handler_raises(self):
+        msg = "raisin"
+
+        def my_handler_raises(obj):
+            raise TypeError(msg)
+
+        with pytest.raises(TypeError, match=msg):
+            DataFrame({"a": [1, 2, object()]}).to_json(
+                default_handler=my_handler_raises
+            )
+        with pytest.raises(TypeError, match=msg):
+            DataFrame({"a": [1, 2, complex(4, -5)]}).to_json(
+                default_handler=my_handler_raises
+            )
+
+    def test_categorical(self):
+        # GH4377 df.to_json segfaults with non-ndarray blocks
+        df = DataFrame({"A": ["a", "b", "c", "a", "b", "b", "a"]})
+        df["B"] = df["A"]
+        expected = df.to_json()
+
+        df["B"] = df["A"].astype("category")
+        assert expected == df.to_json()
+
+        s = df["A"]
+        sc = df["B"]
+        assert s.to_json() == sc.to_json()
+
+    def test_datetime_tz(self):
+        # GH4377 df.to_json segfaults with non-ndarray blocks
+        tz_range = date_range("20130101", periods=3, tz="US/Eastern")
+        tz_naive = tz_range.tz_convert("utc").tz_localize(None)
+
+        df = DataFrame({"A": tz_range, "B": date_range("20130101", periods=3)})
+
+        df_naive = df.copy()
+        df_naive["A"] = tz_naive
+        expected = df_naive.to_json()
+        assert expected == df.to_json()
+
+        stz = Series(tz_range)
+        s_naive = Series(tz_naive)
+        assert stz.to_json() == s_naive.to_json()
+
+    def test_sparse(self):
+        # GH4377 df.to_json segfaults with non-ndarray blocks
+        df = DataFrame(np.random.default_rng(2).standard_normal((10, 4)))
+        df.loc[:8] = np.nan
+
+        sdf = df.astype("Sparse")
+        expected = df.to_json()
+        assert expected == sdf.to_json()
+
+        s = Series(np.random.default_rng(2).standard_normal(10))
+        s.loc[:8] = np.nan
+        ss = s.astype("Sparse")
+
+        expected = s.to_json()
+        assert expected == ss.to_json()
+
+    @pytest.mark.parametrize(
+        "ts",
+        [
+            Timestamp("2013-01-10 05:00:00Z"),
+            Timestamp("2013-01-10 00:00:00", tz="US/Eastern"),
+            Timestamp("2013-01-10 00:00:00-0500"),
+        ],
+    )
+    def test_tz_is_utc(self, ts):
+        exp = '"2013-01-10T05:00:00.000Z"'
+
+        assert ujson_dumps(ts, iso_dates=True) == exp
+        dt = ts.to_pydatetime()
+        assert ujson_dumps(dt, iso_dates=True) == exp
+
+    def test_tz_is_naive(self):
+        ts = Timestamp("2013-01-10 05:00:00")
+        exp = '"2013-01-10T05:00:00.000"'
+
+        assert ujson_dumps(ts, iso_dates=True) == exp
+        dt = ts.to_pydatetime()
+        assert ujson_dumps(dt, iso_dates=True) == exp
+
+    @pytest.mark.parametrize(
+        "tz_range",
+        [
+            date_range("2013-01-01 05:00:00Z", periods=2),
+            date_range("2013-01-01 00:00:00", periods=2, tz="US/Eastern"),
+            date_range("2013-01-01 00:00:00-0500", periods=2),
+        ],
+    )
+    def test_tz_range_is_utc(self, tz_range):
+        exp = '["2013-01-01T05:00:00.000Z","2013-01-02T05:00:00.000Z"]'
+        dfexp = (
+            '{"DT":{'
+            '"0":"2013-01-01T05:00:00.000Z",'
+            '"1":"2013-01-02T05:00:00.000Z"}}'
+        )
+
+        assert ujson_dumps(tz_range, iso_dates=True) == exp
+        dti = DatetimeIndex(tz_range)
+        # Ensure datetimes in object array are serialized correctly
+        # in addition to the normal DTI case
+        assert ujson_dumps(dti, iso_dates=True) == exp
+        assert ujson_dumps(dti.astype(object), iso_dates=True) == exp
+        df = DataFrame({"DT": dti})
+        result = ujson_dumps(df, iso_dates=True)
+        assert result == dfexp
+        assert ujson_dumps(df.astype({"DT": object}), iso_dates=True)
+
+    def test_tz_range_is_naive(self):
+        dti = date_range("2013-01-01 05:00:00", periods=2)
+
+        exp = '["2013-01-01T05:00:00.000","2013-01-02T05:00:00.000"]'
+        dfexp = '{"DT":{"0":"2013-01-01T05:00:00.000","1":"2013-01-02T05:00:00.000"}}'
+
+        # Ensure datetimes in object array are serialized correctly
+        # in addition to the normal DTI case
+        assert ujson_dumps(dti, iso_dates=True) == exp
+        assert ujson_dumps(dti.astype(object), iso_dates=True) == exp
+        df = DataFrame({"DT": dti})
+        result = ujson_dumps(df, iso_dates=True)
+        assert result == dfexp
+        assert ujson_dumps(df.astype({"DT": object}), iso_dates=True)
+
+    def test_read_inline_jsonl(self):
+        # 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)
+
+    @pytest.mark.single_cpu
+    @td.skip_if_not_us_locale
+    def test_read_s3_jsonl(self, s3_public_bucket_with_data, s3so):
+        # GH17200
+
+        result = read_json(
+            f"s3n://{s3_public_bucket_with_data.name}/items.jsonl",
+            lines=True,
+            storage_options=s3so,
+        )
+        expected = DataFrame([[1, 2], [1, 2]], columns=["a", "b"])
+        tm.assert_frame_equal(result, expected)
+
+    def test_read_local_jsonl(self):
+        # GH17200
+        with tm.ensure_clean("tmp_items.json") as path:
+            with open(path, "w", encoding="utf-8") as infile:
+                infile.write('{"a": 1, "b": 2}\n{"b":2, "a" :1}\n')
+            result = read_json(path, lines=True)
+            expected = DataFrame([[1, 2], [1, 2]], columns=["a", "b"])
+            tm.assert_frame_equal(result, expected)
+
+    def test_read_jsonl_unicode_chars(self):
+        # 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 = StringIO('{"a": "foo”", "b": "bar"}\n{"a": "foo", "b": "bar"}\n')
+        result = read_json(json, lines=True)
+        expected = DataFrame([["foo\u201d", "bar"], ["foo", "bar"]], columns=["a", "b"])
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("bigNum", [sys.maxsize + 1, -(sys.maxsize + 2)])
+    def test_to_json_large_numbers(self, bigNum):
+        # GH34473
+        series = Series(bigNum, dtype=object, index=["articleId"])
+        json = series.to_json()
+        expected = '{"articleId":' + str(bigNum) + "}"
+        assert json == expected
+
+        df = DataFrame(bigNum, dtype=object, index=["articleId"], columns=[0])
+        json = df.to_json()
+        expected = '{"0":{"articleId":' + str(bigNum) + "}}"
+        assert json == expected
+
+    @pytest.mark.parametrize("bigNum", [-(2**63) - 1, 2**64])
+    def test_read_json_large_numbers(self, bigNum):
+        # GH20599, 26068
+        json = StringIO('{"articleId":' + str(bigNum) + "}")
+        msg = r"Value is too small|Value is too big"
+        with pytest.raises(ValueError, match=msg):
+            read_json(json)
+
+        json = StringIO('{"0":{"articleId":' + str(bigNum) + "}}")
+        with pytest.raises(ValueError, match=msg):
+            read_json(json)
+
+    def test_read_json_large_numbers2(self):
+        # GH18842
+        json = '{"articleId": "1404366058080022500245"}'
+        json = StringIO(json)
+        result = read_json(json, typ="series")
+        expected = Series(1.404366e21, index=["articleId"])
+        tm.assert_series_equal(result, expected)
+
+        json = '{"0": {"articleId": "1404366058080022500245"}}'
+        json = StringIO(json)
+        result = read_json(json)
+        expected = DataFrame(1.404366e21, index=["articleId"], columns=[0])
+        tm.assert_frame_equal(result, expected)
+
+    def test_to_jsonl(self):
+        # 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)
+
+    # TODO: there is a near-identical test for pytables; can we share?
+    @pytest.mark.xfail(reason="GH#13774 encoding kwarg not supported", raises=TypeError)
+    @pytest.mark.parametrize(
+        "val",
+        [
+            [b"E\xc9, 17", b"", b"a", b"b", b"c"],
+            [b"E\xc9, 17", b"a", b"b", b"c"],
+            [b"EE, 17", b"", b"a", b"b", b"c"],
+            [b"E\xc9, 17", b"\xf8\xfc", b"a", b"b", b"c"],
+            [b"", b"a", b"b", b"c"],
+            [b"\xf8\xfc", b"a", b"b", b"c"],
+            [b"A\xf8\xfc", b"", b"a", b"b", b"c"],
+            [np.nan, b"", b"b", b"c"],
+            [b"A\xf8\xfc", np.nan, b"", b"b", b"c"],
+        ],
+    )
+    @pytest.mark.parametrize("dtype", ["category", object])
+    def test_latin_encoding(self, dtype, val):
+        # GH 13774
+        ser = Series(
+            [x.decode("latin-1") if isinstance(x, bytes) else x for x in val],
+            dtype=dtype,
+        )
+        encoding = "latin-1"
+        with tm.ensure_clean("test.json") as path:
+            ser.to_json(path, encoding=encoding)
+            retr = read_json(StringIO(path), encoding=encoding)
+            tm.assert_series_equal(ser, retr, check_categorical=False)
+
+    def test_data_frame_size_after_to_json(self):
+        # GH15344
+        df = DataFrame({"a": [str(1)]})
+
+        size_before = df.memory_usage(index=True, deep=True).sum()
+        df.to_json()
+        size_after = df.memory_usage(index=True, deep=True).sum()
+
+        assert size_before == size_after
+
+    @pytest.mark.parametrize(
+        "index", [None, [1, 2], [1.0, 2.0], ["a", "b"], ["1", "2"], ["1.", "2."]]
+    )
+    @pytest.mark.parametrize("columns", [["a", "b"], ["1", "2"], ["1.", "2."]])
+    def test_from_json_to_json_table_index_and_columns(self, index, columns):
+        # GH25433 GH25435
+        expected = DataFrame([[1, 2], [3, 4]], index=index, columns=columns)
+        dfjson = expected.to_json(orient="table")
+
+        result = read_json(StringIO(dfjson), orient="table")
+        tm.assert_frame_equal(result, expected)
+
+    def test_from_json_to_json_table_dtypes(self):
+        # GH21345
+        expected = DataFrame({"a": [1, 2], "b": [3.0, 4.0], "c": ["5", "6"]})
+        dfjson = expected.to_json(orient="table")
+        result = read_json(StringIO(dfjson), orient="table")
+        tm.assert_frame_equal(result, expected)
+
+    # TODO: We are casting to string which coerces None to NaN before casting back
+    # to object, ending up with incorrect na values
+    @pytest.mark.xfail(using_pyarrow_string_dtype(), reason="incorrect na conversion")
+    @pytest.mark.parametrize("orient", ["split", "records", "index", "columns"])
+    def test_to_json_from_json_columns_dtypes(self, orient):
+        # GH21892 GH33205
+        expected = DataFrame.from_dict(
+            {
+                "Integer": Series([1, 2, 3], dtype="int64"),
+                "Float": Series([None, 2.0, 3.0], dtype="float64"),
+                "Object": Series([None, "", "c"], dtype="object"),
+                "Bool": Series([True, False, True], dtype="bool"),
+                "Category": Series(["a", "b", None], dtype="category"),
+                "Datetime": Series(
+                    ["2020-01-01", None, "2020-01-03"], dtype="datetime64[ns]"
+                ),
+            }
+        )
+        dfjson = expected.to_json(orient=orient)
+
+        result = read_json(
+            StringIO(dfjson),
+            orient=orient,
+            dtype={
+                "Integer": "int64",
+                "Float": "float64",
+                "Object": "object",
+                "Bool": "bool",
+                "Category": "category",
+                "Datetime": "datetime64[ns]",
+            },
+        )
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("dtype", [True, {"b": int, "c": int}])
+    def test_read_json_table_dtype_raises(self, dtype):
+        # GH21345
+        df = DataFrame({"a": [1, 2], "b": [3.0, 4.0], "c": ["5", "6"]})
+        dfjson = df.to_json(orient="table")
+        msg = "cannot pass both dtype and orient='table'"
+        with pytest.raises(ValueError, match=msg):
+            read_json(dfjson, orient="table", dtype=dtype)
+
+    @pytest.mark.parametrize("orient", ["index", "columns", "records", "values"])
+    def test_read_json_table_empty_axes_dtype(self, orient):
+        # GH28558
+
+        expected = DataFrame()
+        result = read_json(StringIO("{}"), orient=orient, convert_axes=True)
+        tm.assert_index_equal(result.index, expected.index)
+        tm.assert_index_equal(result.columns, expected.columns)
+
+    def test_read_json_table_convert_axes_raises(self):
+        # GH25433 GH25435
+        df = DataFrame([[1, 2], [3, 4]], index=[1.0, 2.0], columns=["1.", "2."])
+        dfjson = df.to_json(orient="table")
+        msg = "cannot pass both convert_axes and orient='table'"
+        with pytest.raises(ValueError, match=msg):
+            read_json(dfjson, orient="table", convert_axes=True)
+
+    @pytest.mark.parametrize(
+        "data, expected",
+        [
+            (
+                DataFrame([[1, 2], [4, 5]], columns=["a", "b"]),
+                {"columns": ["a", "b"], "data": [[1, 2], [4, 5]]},
+            ),
+            (
+                DataFrame([[1, 2], [4, 5]], columns=["a", "b"]).rename_axis("foo"),
+                {"columns": ["a", "b"], "data": [[1, 2], [4, 5]]},
+            ),
+            (
+                DataFrame(
+                    [[1, 2], [4, 5]], columns=["a", "b"], index=[["a", "b"], ["c", "d"]]
+                ),
+                {"columns": ["a", "b"], "data": [[1, 2], [4, 5]]},
+            ),
+            (Series([1, 2, 3], name="A"), {"name": "A", "data": [1, 2, 3]}),
+            (
+                Series([1, 2, 3], name="A").rename_axis("foo"),
+                {"name": "A", "data": [1, 2, 3]},
+            ),
+            (
+                Series([1, 2], name="A", index=[["a", "b"], ["c", "d"]]),
+                {"name": "A", "data": [1, 2]},
+            ),
+        ],
+    )
+    def test_index_false_to_json_split(self, data, expected):
+        # GH 17394
+        # Testing index=False in to_json with orient='split'
+
+        result = data.to_json(orient="split", index=False)
+        result = json.loads(result)
+
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "data",
+        [
+            (DataFrame([[1, 2], [4, 5]], columns=["a", "b"])),
+            (DataFrame([[1, 2], [4, 5]], columns=["a", "b"]).rename_axis("foo")),
+            (
+                DataFrame(
+                    [[1, 2], [4, 5]], columns=["a", "b"], index=[["a", "b"], ["c", "d"]]
+                )
+            ),
+            (Series([1, 2, 3], name="A")),
+            (Series([1, 2, 3], name="A").rename_axis("foo")),
+            (Series([1, 2], name="A", index=[["a", "b"], ["c", "d"]])),
+        ],
+    )
+    def test_index_false_to_json_table(self, data):
+        # GH 17394
+        # Testing index=False in to_json with orient='table'
+
+        result = data.to_json(orient="table", index=False)
+        result = json.loads(result)
+
+        expected = {
+            "schema": pd.io.json.build_table_schema(data, index=False),
+            "data": DataFrame(data).to_dict(orient="records"),
+        }
+
+        assert result == expected
+
+    @pytest.mark.parametrize("orient", ["index", "columns"])
+    def test_index_false_error_to_json(self, orient):
+        # GH 17394, 25513
+        # Testing error message from to_json with index=False
+
+        df = DataFrame([[1, 2], [4, 5]], columns=["a", "b"])
+
+        msg = (
+            "'index=False' is only valid when 'orient' is 'split', "
+            "'table', 'records', or 'values'"
+        )
+        with pytest.raises(ValueError, match=msg):
+            df.to_json(orient=orient, index=False)
+
+    @pytest.mark.parametrize("orient", ["records", "values"])
+    def test_index_true_error_to_json(self, orient):
+        # GH 25513
+        # Testing error message from to_json with index=True
+
+        df = DataFrame([[1, 2], [4, 5]], columns=["a", "b"])
+
+        msg = (
+            "'index=True' is only valid when 'orient' is 'split', "
+            "'table', 'index', or 'columns'"
+        )
+        with pytest.raises(ValueError, match=msg):
+            df.to_json(orient=orient, index=True)
+
+    @pytest.mark.parametrize("orient", ["split", "table"])
+    @pytest.mark.parametrize("index", [True, False])
+    def test_index_false_from_json_to_json(self, orient, index):
+        # GH25170
+        # Test index=False in from_json to_json
+        expected = DataFrame({"a": [1, 2], "b": [3, 4]})
+        dfjson = expected.to_json(orient=orient, index=index)
+        result = read_json(StringIO(dfjson), orient=orient)
+        tm.assert_frame_equal(result, expected)
+
+    def test_read_timezone_information(self):
+        # GH 25546
+        result = read_json(
+            StringIO('{"2019-01-01T11:00:00.000Z":88}'), typ="series", orient="index"
+        )
+        exp_dti = DatetimeIndex(["2019-01-01 11:00:00"], dtype="M8[ns, UTC]")
+        expected = Series([88], index=exp_dti)
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "url",
+        [
+            "s3://example-fsspec/",
+            "gcs://another-fsspec/file.json",
+            "https://example-site.com/data",
+            "some-protocol://data.txt",
+        ],
+    )
+    def test_read_json_with_url_value(self, url):
+        # GH 36271
+        result = read_json(StringIO(f'{{"url":{{"0":"{url}"}}}}'))
+        expected = DataFrame({"url": [url]})
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "compression",
+        ["", ".gz", ".bz2", ".tar"],
+    )
+    def test_read_json_with_very_long_file_path(self, compression):
+        # GH 46718
+        long_json_path = f'{"a" * 1000}.json{compression}'
+        with pytest.raises(
+            FileNotFoundError, match=f"File {long_json_path} does not exist"
+        ):
+            # path too long for Windows is handled in file_exists() but raises in
+            # _get_data_from_filepath()
+            read_json(long_json_path)
+
+    @pytest.mark.parametrize(
+        "date_format,key", [("epoch", 86400000), ("iso", "P1DT0H0M0S")]
+    )
+    def test_timedelta_as_label(self, date_format, key):
+        df = DataFrame([[1]], columns=[pd.Timedelta("1D")])
+        expected = f'{{"{key}":{{"0":1}}}}'
+        result = df.to_json(date_format=date_format)
+
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "orient,expected",
+        [
+            ("index", "{\"('a', 'b')\":{\"('c', 'd')\":1}}"),
+            ("columns", "{\"('c', 'd')\":{\"('a', 'b')\":1}}"),
+            # TODO: the below have separate encoding procedures
+            pytest.param(
+                "split",
+                "",
+                marks=pytest.mark.xfail(
+                    reason="Produces JSON but not in a consistent manner"
+                ),
+            ),
+            pytest.param(
+                "table",
+                "",
+                marks=pytest.mark.xfail(
+                    reason="Produces JSON but not in a consistent manner"
+                ),
+            ),
+        ],
+    )
+    def test_tuple_labels(self, orient, expected):
+        # GH 20500
+        df = DataFrame([[1]], index=[("a", "b")], columns=[("c", "d")])
+        result = df.to_json(orient=orient)
+        assert result == expected
+
+    @pytest.mark.parametrize("indent", [1, 2, 4])
+    def test_to_json_indent(self, indent):
+        # GH 12004
+        df = DataFrame([["foo", "bar"], ["baz", "qux"]], columns=["a", "b"])
+
+        result = df.to_json(indent=indent)
+        spaces = " " * indent
+        expected = f"""{{
+{spaces}"a":{{
+{spaces}{spaces}"0":"foo",
+{spaces}{spaces}"1":"baz"
+{spaces}}},
+{spaces}"b":{{
+{spaces}{spaces}"0":"bar",
+{spaces}{spaces}"1":"qux"
+{spaces}}}
+}}"""
+
+        assert result == expected
+
+    @pytest.mark.skipif(
+        using_pyarrow_string_dtype(),
+        reason="Adjust expected when infer_string is default, no bug here, "
+        "just a complicated parametrization",
+    )
+    @pytest.mark.parametrize(
+        "orient,expected",
+        [
+            (
+                "split",
+                """{
+    "columns":[
+        "a",
+        "b"
+    ],
+    "index":[
+        0,
+        1
+    ],
+    "data":[
+        [
+            "foo",
+            "bar"
+        ],
+        [
+            "baz",
+            "qux"
+        ]
+    ]
+}""",
+            ),
+            (
+                "records",
+                """[
+    {
+        "a":"foo",
+        "b":"bar"
+    },
+    {
+        "a":"baz",
+        "b":"qux"
+    }
+]""",
+            ),
+            (
+                "index",
+                """{
+    "0":{
+        "a":"foo",
+        "b":"bar"
+    },
+    "1":{
+        "a":"baz",
+        "b":"qux"
+    }
+}""",
+            ),
+            (
+                "columns",
+                """{
+    "a":{
+        "0":"foo",
+        "1":"baz"
+    },
+    "b":{
+        "0":"bar",
+        "1":"qux"
+    }
+}""",
+            ),
+            (
+                "values",
+                """[
+    [
+        "foo",
+        "bar"
+    ],
+    [
+        "baz",
+        "qux"
+    ]
+]""",
+            ),
+            (
+                "table",
+                """{
+    "schema":{
+        "fields":[
+            {
+                "name":"index",
+                "type":"integer"
+            },
+            {
+                "name":"a",
+                "type":"string"
+            },
+            {
+                "name":"b",
+                "type":"string"
+            }
+        ],
+        "primaryKey":[
+            "index"
+        ],
+        "pandas_version":"1.4.0"
+    },
+    "data":[
+        {
+            "index":0,
+            "a":"foo",
+            "b":"bar"
+        },
+        {
+            "index":1,
+            "a":"baz",
+            "b":"qux"
+        }
+    ]
+}""",
+            ),
+        ],
+    )
+    def test_json_indent_all_orients(self, orient, expected):
+        # GH 12004
+        df = DataFrame([["foo", "bar"], ["baz", "qux"]], columns=["a", "b"])
+        result = df.to_json(orient=orient, indent=4)
+        assert result == expected
+
+    def test_json_negative_indent_raises(self):
+        with pytest.raises(ValueError, match="must be a nonnegative integer"):
+            DataFrame().to_json(indent=-1)
+
+    def test_emca_262_nan_inf_support(self):
+        # GH 12213
+        data = StringIO(
+            '["a", NaN, "NaN", Infinity, "Infinity", -Infinity, "-Infinity"]'
+        )
+        result = read_json(data)
+        expected = DataFrame(
+            ["a", None, "NaN", np.inf, "Infinity", -np.inf, "-Infinity"]
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_frame_int_overflow(self):
+        # GH 30320
+        encoded_json = json.dumps([{"col": "31900441201190696999"}, {"col": "Text"}])
+        expected = DataFrame({"col": ["31900441201190696999", "Text"]})
+        result = read_json(StringIO(encoded_json))
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "dataframe,expected",
+        [
+            (
+                DataFrame({"x": [1, 2, 3], "y": ["a", "b", "c"]}),
+                '{"(0, \'x\')":1,"(0, \'y\')":"a","(1, \'x\')":2,'
+                '"(1, \'y\')":"b","(2, \'x\')":3,"(2, \'y\')":"c"}',
+            )
+        ],
+    )
+    def test_json_multiindex(self, dataframe, expected):
+        series = dataframe.stack(future_stack=True)
+        result = series.to_json(orient="index")
+        assert result == expected
+
+    @pytest.mark.single_cpu
+    def test_to_s3(self, s3_public_bucket, s3so):
+        # GH 28375
+        mock_bucket_name, target_file = s3_public_bucket.name, "test.json"
+        df = DataFrame({"x": [1, 2, 3], "y": [2, 4, 6]})
+        df.to_json(f"s3://{mock_bucket_name}/{target_file}", storage_options=s3so)
+        timeout = 5
+        while True:
+            if target_file in (obj.key for obj in s3_public_bucket.objects.all()):
+                break
+            time.sleep(0.1)
+            timeout -= 0.1
+            assert timeout > 0, "Timed out waiting for file to appear on moto"
+
+    def test_json_pandas_nulls(self, nulls_fixture, request):
+        # GH 31615
+        if isinstance(nulls_fixture, Decimal):
+            mark = pytest.mark.xfail(reason="not implemented")
+            request.applymarker(mark)
+
+        result = DataFrame([[nulls_fixture]]).to_json()
+        assert result == '{"0":{"0":null}}'
+
+    def test_readjson_bool_series(self):
+        # GH31464
+        result = read_json(StringIO("[true, true, false]"), typ="series")
+        expected = Series([True, True, False])
+        tm.assert_series_equal(result, expected)
+
+    def test_to_json_multiindex_escape(self):
+        # GH 15273
+        df = DataFrame(
+            True,
+            index=date_range("2017-01-20", "2017-01-23"),
+            columns=["foo", "bar"],
+        ).stack(future_stack=True)
+        result = df.to_json()
+        expected = (
+            "{\"(Timestamp('2017-01-20 00:00:00'), 'foo')\":true,"
+            "\"(Timestamp('2017-01-20 00:00:00'), 'bar')\":true,"
+            "\"(Timestamp('2017-01-21 00:00:00'), 'foo')\":true,"
+            "\"(Timestamp('2017-01-21 00:00:00'), 'bar')\":true,"
+            "\"(Timestamp('2017-01-22 00:00:00'), 'foo')\":true,"
+            "\"(Timestamp('2017-01-22 00:00:00'), 'bar')\":true,"
+            "\"(Timestamp('2017-01-23 00:00:00'), 'foo')\":true,"
+            "\"(Timestamp('2017-01-23 00:00:00'), 'bar')\":true}"
+        )
+        assert result == expected
+
+    def test_to_json_series_of_objects(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
+        series = Series([_TestObject(a=1, b=2, _c=3, d=4)])
+        assert json.loads(series.to_json()) == {"0": {"a": 1, "b": 2, "d": 4}}
+
+    @pytest.mark.parametrize(
+        "data,expected",
+        [
+            (
+                Series({0: -6 + 8j, 1: 0 + 1j, 2: 9 - 5j}),
+                '{"0":{"imag":8.0,"real":-6.0},'
+                '"1":{"imag":1.0,"real":0.0},'
+                '"2":{"imag":-5.0,"real":9.0}}',
+            ),
+            (
+                Series({0: -9.39 + 0.66j, 1: 3.95 + 9.32j, 2: 4.03 - 0.17j}),
+                '{"0":{"imag":0.66,"real":-9.39},'
+                '"1":{"imag":9.32,"real":3.95},'
+                '"2":{"imag":-0.17,"real":4.03}}',
+            ),
+            (
+                DataFrame([[-2 + 3j, -1 - 0j], [4 - 3j, -0 - 10j]]),
+                '{"0":{"0":{"imag":3.0,"real":-2.0},'
+                '"1":{"imag":-3.0,"real":4.0}},'
+                '"1":{"0":{"imag":0.0,"real":-1.0},'
+                '"1":{"imag":-10.0,"real":0.0}}}',
+            ),
+            (
+                DataFrame(
+                    [[-0.28 + 0.34j, -1.08 - 0.39j], [0.41 - 0.34j, -0.78 - 1.35j]]
+                ),
+                '{"0":{"0":{"imag":0.34,"real":-0.28},'
+                '"1":{"imag":-0.34,"real":0.41}},'
+                '"1":{"0":{"imag":-0.39,"real":-1.08},'
+                '"1":{"imag":-1.35,"real":-0.78}}}',
+            ),
+        ],
+    )
+    def test_complex_data_tojson(self, data, expected):
+        # GH41174
+        result = data.to_json()
+        assert result == expected
+
+    def test_json_uint64(self):
+        # GH21073
+        expected = (
+            '{"columns":["col1"],"index":[0,1],'
+            '"data":[[13342205958987758245],[12388075603347835679]]}'
+        )
+        df = DataFrame(data={"col1": [13342205958987758245, 12388075603347835679]})
+        result = df.to_json(orient="split")
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "orient", ["split", "records", "values", "index", "columns"]
+    )
+    def test_read_json_dtype_backend(
+        self, string_storage, dtype_backend, orient, using_infer_string
+    ):
+        # GH#50750
+        pa = pytest.importorskip("pyarrow")
+        df = DataFrame(
+            {
+                "a": Series([1, np.nan, 3], dtype="Int64"),
+                "b": Series([1, 2, 3], dtype="Int64"),
+                "c": Series([1.5, np.nan, 2.5], dtype="Float64"),
+                "d": Series([1.5, 2.0, 2.5], dtype="Float64"),
+                "e": [True, False, None],
+                "f": [True, False, True],
+                "g": ["a", "b", "c"],
+                "h": ["a", "b", None],
+            }
+        )
+
+        if using_infer_string:
+            string_array = ArrowStringArrayNumpySemantics(pa.array(["a", "b", "c"]))
+            string_array_na = ArrowStringArrayNumpySemantics(pa.array(["a", "b", None]))
+        elif string_storage == "python":
+            string_array = StringArray(np.array(["a", "b", "c"], dtype=np.object_))
+            string_array_na = StringArray(np.array(["a", "b", NA], dtype=np.object_))
+
+        elif dtype_backend == "pyarrow":
+            pa = pytest.importorskip("pyarrow")
+            from pandas.arrays import ArrowExtensionArray
+
+            string_array = ArrowExtensionArray(pa.array(["a", "b", "c"]))
+            string_array_na = ArrowExtensionArray(pa.array(["a", "b", None]))
+
+        else:
+            string_array = ArrowStringArray(pa.array(["a", "b", "c"]))
+            string_array_na = ArrowStringArray(pa.array(["a", "b", None]))
+
+        out = df.to_json(orient=orient)
+        with pd.option_context("mode.string_storage", string_storage):
+            result = read_json(
+                StringIO(out), dtype_backend=dtype_backend, orient=orient
+            )
+
+        expected = DataFrame(
+            {
+                "a": Series([1, np.nan, 3], dtype="Int64"),
+                "b": Series([1, 2, 3], dtype="Int64"),
+                "c": Series([1.5, np.nan, 2.5], dtype="Float64"),
+                "d": Series([1.5, 2.0, 2.5], dtype="Float64"),
+                "e": Series([True, False, NA], dtype="boolean"),
+                "f": Series([True, False, True], dtype="boolean"),
+                "g": string_array,
+                "h": string_array_na,
+            }
+        )
+
+        if dtype_backend == "pyarrow":
+            from pandas.arrays import ArrowExtensionArray
+
+            expected = DataFrame(
+                {
+                    col: ArrowExtensionArray(pa.array(expected[col], from_pandas=True))
+                    for col in expected.columns
+                }
+            )
+
+        if orient == "values":
+            expected.columns = list(range(8))
+
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("orient", ["split", "records", "index"])
+    def test_read_json_nullable_series(self, string_storage, dtype_backend, orient):
+        # GH#50750
+        pa = pytest.importorskip("pyarrow")
+        ser = Series([1, np.nan, 3], dtype="Int64")
+
+        out = ser.to_json(orient=orient)
+        with pd.option_context("mode.string_storage", string_storage):
+            result = read_json(
+                StringIO(out), dtype_backend=dtype_backend, orient=orient, typ="series"
+            )
+
+        expected = Series([1, np.nan, 3], dtype="Int64")
+
+        if dtype_backend == "pyarrow":
+            from pandas.arrays import ArrowExtensionArray
+
+            expected = Series(ArrowExtensionArray(pa.array(expected, from_pandas=True)))
+
+        tm.assert_series_equal(result, expected)
+
+    def test_invalid_dtype_backend(self):
+        msg = (
+            "dtype_backend numpy is invalid, only 'numpy_nullable' and "
+            "'pyarrow' are allowed."
+        )
+        with pytest.raises(ValueError, match=msg):
+            read_json("test", dtype_backend="numpy")
+
+
+def test_invalid_engine():
+    # GH 48893
+    ser = Series(range(1))
+    out = ser.to_json()
+    with pytest.raises(ValueError, match="The engine type foo"):
+        read_json(out, engine="foo")
+
+
+def test_pyarrow_engine_lines_false():
+    # GH 48893
+    ser = Series(range(1))
+    out = ser.to_json()
+    with pytest.raises(ValueError, match="currently pyarrow engine only supports"):
+        read_json(out, engine="pyarrow", lines=False)
+
+
+def test_json_roundtrip_string_inference(orient):
+    pytest.importorskip("pyarrow")
+    df = DataFrame(
+        [["a", "b"], ["c", "d"]], index=["row 1", "row 2"], columns=["col 1", "col 2"]
+    )
+    out = df.to_json()
+    with pd.option_context("future.infer_string", True):
+        result = read_json(StringIO(out))
+    expected = DataFrame(
+        [["a", "b"], ["c", "d"]],
+        dtype="string[pyarrow_numpy]",
+        index=Index(["row 1", "row 2"], dtype="string[pyarrow_numpy]"),
+        columns=Index(["col 1", "col 2"], dtype="string[pyarrow_numpy]"),
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_json_pos_args_deprecation():
+    # GH-54229
+    df = DataFrame({"a": [1, 2, 3]})
+    msg = (
+        r"Starting with pandas version 3.0 all arguments of to_json except for the "
+        r"argument 'path_or_buf' will be keyword-only."
+    )
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        buf = BytesIO()
+        df.to_json(buf, "split")
+
+
+@td.skip_if_no("pyarrow")
+def test_to_json_ea_null():
+    # GH#57224
+    df = DataFrame(
+        {
+            "a": Series([1, NA], dtype="int64[pyarrow]"),
+            "b": Series([2, NA], dtype="Int64"),
+        }
+    )
+    result = df.to_json(orient="records", lines=True)
+    expected = """{"a":1,"b":2}
+{"a":null,"b":null}
+"""
+    assert result == expected
+
+
+def test_read_json_lines_rangeindex():
+    # GH 57429
+    data = """
+{"a": 1, "b": 2}
+{"a": 3, "b": 4}
+"""
+    result = read_json(StringIO(data), lines=True).index
+    expected = RangeIndex(2)
+    tm.assert_index_equal(result, expected, exact=True)

llmeval-env/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)

llmeval-env/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() == "{}"

llmeval-env/lib/python3.10/site-packages/pandas/tests/io/pytables/common.py

@@ -0,0 +1,50 @@
+from collections.abc import Generator
+from contextlib import contextmanager
+import pathlib
+import tempfile
+
+import pytest
+
+from pandas.io.pytables import HDFStore
+
+tables = pytest.importorskip("tables")
+# set these parameters so we don't have file sharing
+tables.parameters.MAX_NUMEXPR_THREADS = 1
+tables.parameters.MAX_BLOSC_THREADS = 1
+tables.parameters.MAX_THREADS = 1
+
+
+def safe_close(store):
+    try:
+        if store is not None:
+            store.close()
+    except OSError:
+        pass
+
+
+# contextmanager to ensure the file cleanup
+@contextmanager
+def ensure_clean_store(
+    path, mode="a", complevel=None, complib=None, fletcher32=False
+) -> Generator[HDFStore, None, None]:
+    with tempfile.TemporaryDirectory() as tmpdirname:
+        tmp_path = pathlib.Path(tmpdirname, path)
+        with HDFStore(
+            tmp_path,
+            mode=mode,
+            complevel=complevel,
+            complib=complib,
+            fletcher32=fletcher32,
+        ) as store:
+            yield store
+
+
+def _maybe_remove(store, key):
+    """
+    For tests using tables, try removing the table to be sure there is
+    no content from previous tests using the same table name.
+    """
+    try:
+        store.remove(key)
+    except (ValueError, KeyError):
+        pass

llmeval-env/lib/python3.10/site-packages/pandas/tests/io/pytables/conftest.py

@@ -0,0 +1,9 @@
+import uuid
+
+import pytest
+
+
+@pytest.fixture
+def setup_path():
+    """Fixture for setup path"""
+    return f"tmp.__{uuid.uuid4()}__.h5"